diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index f22921b7049..00000000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-ko_fi: coteschung
-custom: https://sponsor.cotes.page
diff --git a/.github/workflows/pages-deploy.yml b/.github/workflows/pages-deploy.yml
new file mode 100644
index 00000000000..4f8346a64c3
--- /dev/null
+++ b/.github/workflows/pages-deploy.yml
@@ -0,0 +1,77 @@
+name: "Build and Deploy"
+on:
+  push:
+    branches:
+      - master
+      - main
+    paths-ignore:
+      - .gitignore
+      - README.md
+      - LICENSE
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          # submodules: true
+          # If using the 'assets' git submodule from Chirpy Starter, uncomment above
+          # (See: https://github.com/cotes2020/chirpy-starter/tree/main/assets)
+
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v4
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+<<<<<<<< HEAD:.github/workflows/pages-deploy.yml
+          ruby-version: 2.7 # reads from a '.ruby-version' or '.tools-version' file if 'ruby-version' is omitted
+========
+          ruby-version: 3.3
+>>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041:.github/workflows/starter/pages-deploy.yml
+          bundler-cache: true
+
+      - name: Build site
+        run: bundle exec jekyll b -d "_site${{ steps.pages.outputs.base_path }}"
+        env:
+          JEKYLL_ENV: "production"
+
+      - name: Test site
+        run: |
+          bundle exec htmlproofer _site \
+            \-\-disable-external \
+            \-\-ignore-urls "/^http:\/\/127.0.0.1/,/^http:\/\/0.0.0.0/,/^http:\/\/localhost/"
+
+      - name: Upload site artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: "_site${{ steps.pages.outputs.base_path }}"
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/starter/pages-deploy.yml b/.github/workflows/starter/pages-deploy.yml
index cc28f99fd25..4f8346a64c3 100644
--- a/.github/workflows/starter/pages-deploy.yml
+++ b/.github/workflows/starter/pages-deploy.yml
@@ -2,8 +2,8 @@ name: "Build and Deploy"
 on:
   push:
     branches:
-      - main
       - master
+      - main
     paths-ignore:
       - .gitignore
       - README.md
@@ -42,7 +42,11 @@ jobs:
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
+<<<<<<<< HEAD:.github/workflows/pages-deploy.yml
+          ruby-version: 2.7 # reads from a '.ruby-version' or '.tools-version' file if 'ruby-version' is omitted
+========
           ruby-version: 3.3
+>>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041:.github/workflows/starter/pages-deploy.yml
           bundler-cache: true
 
       - name: Build site
diff --git a/README.md b/README.md
index 7e57b2a52e2..4cc2e4b937e 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,10 @@
+<<<<<<< HEAD
+<div>
+  <!--Header-->
+  
+  ![header](https://capsule-render.vercel.app/api?type=venom&color=gradient&height=300&section=header&text=Germanus'%20GitHub)
+  
+=======
 <!-- markdownlint-disable-next-line -->
 <div align="center">
 
@@ -16,10 +23,87 @@
 
   [![Devices Mockup](https://chirpy-img.netlify.app/commons/devices-mockup.png)][demo]
 
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
 </div>
 
-## Features
-
+<div>
+  <!--Body-->
+  
+  ## 👀 About Me
+  #### :fire: AI / Backend / DevOps 개발자가 되기 위해 공부하고 있습니다.<br/>
+  #### :mortar_board: 경상국립대학교(GNU), 항공우주및소프트웨어공학전공
+  #### :black_nib: [A Comparison of Pretrained Models for Classifying Issue Reports, IEEE Access](https://ieeexplore.ieee.org/document/10546475)
+  #### :pencil2: SSAFY 12기 Data track (2024.07 - 현재 진행중)
+
+<<<<<<< HEAD
+  ### BOJ Rating
+  [![Solved.ac 프로필](https://mazassumnida.wtf/api/v2/generate_badge?boj=qja1998)](https://solved.ac/qja1998)
+  <br/>
+  <br/>
+  
+  ## 🧱 Tech Stack
+  ### Language
+  <!--Python-->
+  <img src="https://img.shields.io/badge/Python-3776AB?style=flat-square&logo=Python&logoColor=white"/>
+  <!--MySQL-->
+  <img src="https://img.shields.io/badge/MySQL-4479A1?style=flat-square&logo=MySQL&logoColor=white"/>
+  <br/>
+  
+  ### AI / Data
+  <!--PyTorch-->
+  <img src="https://img.shields.io/badge/PyTorch-EE4C2C?style=flat-square&logo=PyTorch&logoColor=white"/>
+  <!--Hugging Face-->
+  <img src="https://img.shields.io/badge/Hugging Face-FFD21E?style=flat-square&logo=huggingface&logoColor=white"/>
+  <!--Pandas-->
+  <img src="https://img.shields.io/badge/pandas-150458?style=flat-square&logo=pandas&logoColor=white"/>
+  <!--Numpy-->
+  <img src="https://img.shields.io/badge/numpy-013243?style=flat-square&logo=numpy&logoColor=white"/>
+  <br/>
+  
+  ### Infra
+  <!--Docker-->
+  <img src="https://img.shields.io/badge/docker-2496ED?style=flat-square&logo=docker&logoColor=white"/>
+  <!--GitLab CI/CD-->
+  <img src="https://img.shields.io/badge/gitlab CI/CD-FC6D26?style=flat-square&logo=gitlab&logoColor=white"/>
+
+  ### Backend
+  <!--Django-->
+  <img src="https://img.shields.io/badge/Django-092E20?style=flat-square&logo=Django&logoColor=white"/>
+  <br/>
+  
+
+  ### Tools
+  <!--git-->
+  <img src="https://img.shields.io/badge/git-F05032?style=flat-square&logo=git&logoColor=white"/>
+  <!--github-->
+  <img src="https://img.shields.io/badge/github-181717?style=flat-square&logo=github&logoColor=white"/>
+  <!--jupyter-->
+  <img src="https://img.shields.io/badge/jupyter-F37626?style=flat-square&logo=jupyter&logoColor=white"/>
+  <!--notion-->
+  <img src="https://img.shields.io/badge/notion-000000?style=flat-square&logo=notion&logoColor=white"/>
+  <br/>
+  <br/>
+  
+  ## 🤔 Github Stats
+  ![](https://github-profile-summary-cards.vercel.app/api/cards/profile-details?username=qja1998&theme=nord_dark)
+
+  ![](https://github-profile-summary-cards.vercel.app/api/cards/repos-per-language?username=qja1998&theme=nord_dark)
+  ![](https://github-profile-summary-cards.vercel.app/api/cards/most-commit-language?username=qja1998&theme=nord_dark)
+
+  ![](https://github-profile-summary-cards.vercel.app/api/cards/stats?username=qja1998&theme=nord_dark)
+  
+  ## Contact
+
+  <!--Blog-->
+  <a href="https://qja1998.github.io/">
+    <img src="https://img.shields.io/badge/github-181717?style=flat-square&logo=github&logoColor=white"/>
+  </a>
+  <!--Mail-->
+  <a href="mailto:rnjsrljqa98@gmail.com">
+    <img src="https://img.shields.io/badge/gmail-EA4335?style=flat-square&logo=gmail&logoColor=white"/>
+  </a>
+</div>
+=======
 - Dark Theme
 - Localized UI language
 - Pinned Posts on Home Page
@@ -82,3 +166,4 @@ This project is published under [MIT License][license].
 [lib]: https://github.com/cotes2020/chirpy-static-assets
 [vscode]: https://code.visualstudio.com/
 [jetbrains]: https://www.jetbrains.com/?from=jekyll-theme-chirpy
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
diff --git a/_config.yml b/_config.yml
index d6f84c57815..421999070fb 100644
--- a/_config.yml
+++ b/_config.yml
@@ -8,25 +8,45 @@ theme: jekyll-theme-chirpy
 # otherwise, the layout language will use the default value of 'en'.
 lang: en
 
+<<<<<<< HEAD
+
+# Change to your timezone › http://www.timezoneconverter.com/cgi-bin/findzone/findzone
+timezone: Asia/Seoul
+=======
 # Change to your timezone › https://kevinnovak.github.io/Time-Zone-Picker
 timezone: Asia/Shanghai
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
 
 # jekyll-seo-tag settings › https://github.com/jekyll/jekyll-seo-tag/blob/master/docs/usage.md
 # ↓ --------------------------
 
+<<<<<<< HEAD
+title: Kwon                          # the main title
+
+tagline: Studying   # it will display as the sub-title
+=======
 title: Chirpy # the main title
 
 tagline: A text-focused Jekyll theme # it will display as the subtitle
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
 
 description: >- # used by seo meta and the atom feed
   A minimal, responsive and feature-rich Jekyll theme for technical writing.
 
+<<<<<<< HEAD
+# fill in the protocol & hostname for your site, e.g., 'https://username.github.io'
+url: 'https://qja1998.github.io'
+
+github:
+  username: qja1998             # change to your github username
+=======
 # Fill in the protocol & hostname for your site.
 # E.g. 'https://username.github.io', note that it does not end with a '/'.
 url: ""
 
 github:
   username: github_username # change to your GitHub username
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
 
 twitter:
   username: twitter_username # change to your Twitter username
@@ -34,12 +54,21 @@ twitter:
 social:
   # Change to your full name.
   # It will be displayed as the default author of the posts and the copyright owner in the Footer
+<<<<<<< HEAD
+  name: GiBeom Kwon
+  email: qja1998@naver.com             # change to your email address
+  links:
+    # The first element serves as the copyright owner's link
+    #- https://twitter.com/username      # change to your twitter homepage
+    - https://github.com/qja1998       # change to your github homepage
+=======
   name: your_full_name
   email: example@domain.com # change to your email address
   links:
     # The first element serves as the copyright owner's link
     - https://twitter.com/username # change to your Twitter homepage
     - https://github.com/username # change to your GitHub homepage
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
     # Uncomment below to add more social links
     # - https://www.facebook.com/username
     # - https://www.linkedin.com/in/username
@@ -88,17 +117,28 @@ pageviews:
 #     light — Use the light color scheme
 #     dark — Use the dark color scheme
 #
+<<<<<<< HEAD
+theme_mode: light  # [light|dark]
+=======
 theme_mode: # [light | dark]
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
 
 # The CDN endpoint for media resources.
 # Notice that once it is assigned, the CDN url
 # will be added to all media resources (site avatar, posts' images, audio and video files) paths starting with '/'
 #
 # e.g. 'https://cdn.com'
+<<<<<<< HEAD
+img_cdn: '/assets/img'
+
+# the avatar on sidebar, support local or CORS resources
+avatar: '/avatar/avatar.jpg'
+=======
 cdn: "https://chirpy-img.netlify.app"
 
 # the avatar on sidebar, support local or CORS resources
 avatar: "/commons/avatar.jpg"
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
 
 # The URL of the site-wide social preview image used in SEO `og:image` meta tag.
 # It can be overridden by a customized `page.image` in front matter.
@@ -108,18 +148,31 @@ social_preview_image: # string, local or CORS resources
 toc: true
 
 comments:
+<<<<<<< HEAD
+  active: utterances         # The global switch for posts comments, e.g., 'disqus'.  Keep it empty means disable
+  # The active options are as follows:
+=======
   # Global switch for the post-comment system. Keeping it empty means disabled.
   provider: # [disqus | utterances | giscus]
   # The provider options are as follows:
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
   disqus:
     shortname: # fill with the Disqus shortname. › https://help.disqus.com/en/articles/1717111-what-s-a-shortname
   # utterances settings › https://utteranc.es/
   utterances:
+<<<<<<< HEAD
+    repo: qja1998/qja1998.github.io        # <gh-username>/<repo>
+    issue_term:   # < url | pathname | title | ...>
+  # Giscus options › https://giscus.app
+  giscus:
+    repo:           # <gh-username>/<repo>
+=======
     repo: # <gh-username>/<repo>
     issue_term: # < url | pathname | title | ...>
   # Giscus options › https://giscus.app
   giscus:
     repo: # <gh-username>/<repo>
+>>>>>>> 54d4d59d22ac543a14bfbd9bb3d6fb6756056041
     repo_id:
     category:
     category_id:
diff --git a/_posts/2022-02-04-boj_10610.markdown b/_posts/2022-02-04-boj_10610.markdown
new file mode 100644
index 00000000000..6ab105150b8
--- /dev/null
+++ b/_posts/2022-02-04-boj_10610.markdown
@@ -0,0 +1,85 @@
+---
+title: "[BOJ] 30 - 10610 (S5)"
+author: kwon
+date: 2022-02-04T23:00:00 +0900
+categories: [boj, silver]
+tags: [math, string, greedy algorithm, sort, number theory]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1 초 | 256 MB |
+
+# 문제
+
+어느 날, 미르코는 우연히 길거리에서 양수 N을 보았다. 미르코는 30이란 수를 존경하기 때문에, 그는 길거리에서 찾은 수에 포함된 숫자들을 섞어 30의 배수가 되는 가장 큰 수를 만들고 싶어한다.
+
+미르코를 도와 그가 만들고 싶어하는 수를 계산하는 프로그램을 작성하라.
+
+# 입력
+
+N을 입력받는다. N는 최대 105개의 숫자로 구성되어 있으며, 0으로 시작하지 않는다.
+
+# 출력
+
+미르코가 만들고 싶어하는 수가 존재한다면 그 수를 출력하라. 그 수가 존재하지 않는다면, -1을 출력하라.
+
+# 풀이
+
+## 첫 번째
+
+입력 받은 수에 0이 없다면 30의 배수를 절대 만들 수 없으므로 먼저 제외한다. 30의 배수인지 판별하기 위해 0을 하나 삭제한 후에 그 수가 3의 배수인지 확인해 본다.
+
+3으로 나누어 떨어지면 3의 배수이므로(모든 자리의 수의 합이 3의 배수이면 3의 배수이므로 수의 배열이 어떻게 되든 3의 배수인지 아닌지 알 수 있다) 내림차순으로 정렬하여 정수로 만든다. 처음에 0을 하나 삭제했으므로 다시 10을 곱해줘야 한다.
+
+### 코드
+
+```python
+nums = list(str(sys.stdin.readline().strip()))
+if '0' not in nums: print(-1)
+else:
+    nums.remove('0')
+    if int(''.join(nums)) % 3 == 0: print(int(''.join(sorted(nums, reverse=True))) * 10)
+    else: print(-1)
+```
+
+## 두 번째
+
+입력 받은 수에 0이 없을 경우 거르는 것은 같다. 다른 점은 내림차순으로 정렬한 뒤에 그 수가 30의 배수인지 확인한다는 것이다.
+
+### 코드
+
+```python
+nums = list(str(sys.stdin.readline().strip()))
+if '0' not in nums: print(-1)
+else:
+    num = int(''.join(sorted(nums, reverse=True)))
+    if num % 30 == 0: print(num)
+    else: print(-1)
+```
+
+## 세 번째
+
+각 자리의 범위는 0~9 사이의 정수이므로 counting sort를 이용하여 풀 수 있다. 각 자리 수들을 index로 하여 개수를 세어 준 다음, 0을 제외한 수들을 역순으로 개수에 맞게 붙이면서 만들면 내림차순으로 정렬된 수를 만들 수 있다.
+
+이를 3의 배수인지 확인하고 0의 개수 만큼의 10의 거듭제곱을 곱해준다.
+
+```python
+import sys
+nums = str(sys.stdin.readline().strip())
+if '0' not in nums:
+    print(-1)
+else:
+    l = [0] * (int(max(nums)) + 1)
+    s = ''
+    sum = 0
+    for i in nums:
+        l[int(i)] += 1
+    for i in range(len(l)-1, 0, -1):
+        s += str(i) * l[i]
+        sum += i * l[i]
+    if sum % 3 == 0: print(int(s) * (10 ** l[0]))
+    else: print(-1)
+```
\ No newline at end of file
diff --git a/_posts/2022-03-11-boj_1011.markdown b/_posts/2022-03-11-boj_1011.markdown
new file mode 100644
index 00000000000..9f9778200b6
--- /dev/null
+++ b/_posts/2022-03-11-boj_1011.markdown
@@ -0,0 +1,67 @@
+---
+title: "[BOJ] Fly me to the Alpha Centauri - 1011 (G5)"
+author: kwon
+date: 2022-03-11T23:00:00 +0900
+categories: [boj, gold]
+tags: [math]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 512 MB |
+
+## 문제
+
+우현이는 어린 시절, 지구 외의 다른 행성에서도 인류들이 살아갈 수 있는 미래가 오리라 믿었다. 그리고 그가 지구라는 세상에 발을 내려 놓은 지 23년이 지난 지금, 세계 최연소 ASNA 우주 비행사가 되어 새로운 세계에 발을 내려 놓는 영광의 순간을 기다리고 있다.
+
+그가 탑승하게 될 우주선은 Alpha Centauri라는 새로운 인류의 보금자리를 개척하기 위한 대규모 생활 유지 시스템을 탑재하고 있기 때문에, 그 크기와 질량이 엄청난 이유로 최신기술력을 총 동원하여 개발한 공간이동 장치를 탑재하였다. 하지만 이 공간이동 장치는 이동 거리를 급격하게 늘릴 경우 기계에 심각한 결함이 발생하는 단점이 있어서, 이전 작동시기에 k광년을 이동하였을 때는 k-1 , k 혹은 k+1 광년만을 다시 이동할 수 있다. 예를 들어, 이 장치를 처음 작동시킬 경우 -1 , 0 , 1 광년을 이론상 이동할 수 있으나 사실상 음수 혹은 0 거리만큼의 이동은 의미가 없으므로 1 광년을 이동할 수 있으며, 그 다음에는 0 , 1 , 2 광년을 이동할 수 있는 것이다. ( 여기서 다시 2광년을 이동한다면 다음 시기엔 1, 2, 3 광년을 이동할 수 있다. )
+
+!https://www.acmicpc.net/upload/201003/rlaehdgur.JPG
+
+김우현은 공간이동 장치 작동시의 에너지 소모가 크다는 점을 잘 알고 있기 때문에 x지점에서 y지점을 향해 최소한의 작동 횟수로 이동하려 한다. 하지만 y지점에 도착해서도 공간 이동장치의 안전성을 위하여 y지점에 도착하기 바로 직전의 이동거리는 반드시 1광년으로 하려 한다.
+
+김우현을 위해 x지점부터 정확히 y지점으로 이동하는데 필요한 공간 이동 장치 작동 횟수의 최솟값을 구하는 프로그램을 작성하라.
+
+## 입력
+
+입력의 첫 줄에는 테스트케이스의 개수 T가 주어진다. 각각의 테스트 케이스에 대해 현재 위치 x 와 목표 위치 y 가 정수로 주어지며, x는 항상 y보다 작은 값을 갖는다. $(0 ≤ x < y < 2^{31})$
+
+## 출력
+
+각 테스트 케이스에 대해 x지점으로부터 y지점까지 정확히 도달하는데 필요한 최소한의 공간이동 장치 작동 횟수를 출력한다.
+
+## 풀이
+
+최소 횟수로 목표에 도달하려면 항상 중간 부분에서 최대 거리로 공간이동을 해야 한다. 그러므로 중간 지점까지는 1씩 늘려가면서 이동하다가 중간을 지나는 순간부터 1씩 줄이면서 이동하면 된다. 하지만 x와 y 사이의 거리가 최대 $2^{31}$까지 늘어날 수 있으므로 이동을 모두 해보는 것은 부적합하다.
+
+그래서 등차수열의 합을 이용한다. 중간까지 이동하는 횟수를 $n$이라고 했을 때 총 이동 거리는 시작항이 1, 마지막항이 $n+1$이고 공차가 1인 등차수열의 합으로 생각할 수 있다. 그리고 이 때 합은 $n(n+1)/2$로 계산하면 된다. 이것을 염두에 두고 가능한 상황을 생각해보면 문제를 풀 수 있다.
+
+여러 상황을 가정해보기 위해 $n$을 거리의 제곱근에 버림을 취한 정수라고 하고 생각해보자.
+
+먼저 중간을 기준으로 양 쪽의 횟수가 같은 경우에는 양쪽 모두가 $n(n+1)/2$로 계산이 되어야 하며 이 때 총 횟수는 $2n$이고, 거리가 정확히 $n(n+1)$일 때 가능하다.
+
+다음은 한 쪽의 횟수가 하나 많은 경우이다. 이 경우 한 쪽은 $n(n+1)/2$이고 반대쪽은 $n(n+2)/2$로 계산이 되어야 한다. 이 때 총 횟수는 $2n+1$이고, 거리가  $n(n+1)$보다 클 때 가능하다.
+
+마지막으로는 한 쪽의 횟수가 하나 적은 경우이다. 이 경우  $n(n+1)/2$이고 반대쪽은 $n(n-1)/2$로 계산이 되어야 한다. 이 때 총 횟수는 $2n-1$이고, 거리가  $n^2$일 때 가능하다.
+
+만약 위 경우에 포함되지 않으면서 거리가 $n(n+1)$보다 크다면 $n$의 크기 자체가 부족한 것이기 때문에 고려하지 않는다.
+
+### 코드
+```python
+import sys, math
+
+i = int(sys.stdin.readline())
+for _ in range(i):
+    n, m = map(int, sys.stdin.readline().split())
+    N = m - n
+    r_N = math.sqrt(N)
+    N_int = math.trunc(r_N)
+    if r_N == N_int: print(N_int * 2 - 1)
+    else:
+        if N > N_int * (N_int + 1):
+            print(N_int * 2 + 1)
+        else:
+            print(N_int * 2)
+```
\ No newline at end of file
diff --git a/_posts/2022-04-14-dlZeroToAll-PyTorch-1.markdown b/_posts/2022-04-14-dlZeroToAll-PyTorch-1.markdown
new file mode 100644
index 00000000000..b629df9d865
--- /dev/null
+++ b/_posts/2022-04-14-dlZeroToAll-PyTorch-1.markdown
@@ -0,0 +1,627 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab1: Tensor Manipulation"
+author: Kwon
+date: 2022-04-14T16:50:00+0900
+categories: [pytorch, study]
+tags: [basic, tensor-manipulation]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 1: Tensor Manipulation 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## 1. Vector, Matrix and Tensor
+![](/posting_imgs/lab1-2.jpg)
+<br><br>
+Vector, Matrix, Tensor의 표현은 위 그림과 같이 나타낼 수 있다.
+
+각 구조들의 크기는 차원들의 크기의 곱으로 구할 수 있는데
+<br><br>
+![](/posting_imgs/lab1-2.jpg)
+<br><br>
+Metrix와 Tonsor의 크기(t)는 위와 같이 구할 수 있다.
+ 
+또한 위 그림의 차원의 순서는 파이토치에서 차원을 표현할 때의 순서와 같다.
+즉, 아래와 같은 순서대로 표현하면 된다.
+<br><br>
+![](/posting_imgs/lab1-3.jpg)
+<br><br>
+크기를 구할 때 봤던 순서를 다시 확인해 보면 Vector는 (batch size, dim)순, Tensor는 (batch size, length, dim)순으로 위 그림과 같은 순서로 표현한 것을 볼 수 있다.
+<br><br>
+
+***
+## Import
+{% highlight python %}
+import numpy as np
+import torch
+{% endhighlight %}
+
+## 2. Array with PyTorch
+#### 1D Array
+{% highlight python %}
+t = torch.FloatTensor([0., 1., 2., 3., 4., 5., 6.])
+print(t)
+
+''' output
+tensor([0., 1., 2., 3., 4., 5., 6.])
+'''
+{% endhighlight %}
+
+1차원 배열의 경우 위와 같이 FloatTensor를 사용하여 배열을 PyTorch의 1차원 실수형 tensor로 변환할 수 있다.
+<br><br>
+#### 2D Array
+{% highlight python %}
+t = torch.FloatTensor([[1., 2., 3.],
+                       [4., 5., 6.],
+                       [7., 8., 9.],
+                       [10., 11., 12.]
+                      ])
+print(t)
+
+''' output
+tensor([[ 1.,  2.,  3.],
+        [ 4.,  5.,  6.],
+        [ 7.,  8.,  9.],
+        [10., 11., 12.]])
+''''
+{% endhighlight %}
+
+2차원 배열의 경우에도 마찬가지로  FloatTensor를 사용하여 배열을 PyTorch의 2차원 실수형 tensor로 변환할 수 있다.
+
+위 예제들에서는 실수형 tensor만을 예로 들었지만 다른 자료형들의 경우도 다음과 같이 tensor 생성이 가능하다.
+
+각 type들에 대한 tensor 생성 방법은 다음과 같다.
+
+{% highlight python %}
+# dtype: torch.float32 or torch.float (32-bit floating point)
+torch.FloatTensor()
+
+# dtype: torch.float64 or torch.double (64-bit floating point)
+torch.FloatTensor()
+
+# dtype: torch.uint8 (8-bit integer (unsigned))
+torch.ByteTensor()
+
+# dtype: torch.int8 (8-bit integer (signed))
+torch.CharTensor()
+
+# dtype: torch.int16 (16-bit integer (signed))
+torch.ShortTensor()
+
+# dtype: torch.int32 (32-bit integer (signed))
+torch.IntTensor()
+
+# dtype: torch.int64 (64-bit integer (signed))
+torch.LongTensor()
+
+# dtype: torch.bool
+torch.BoolTensor()
+{% endhighlight %}
+
+위와 같이 타입을 지정하여 tensor를 생성해도 되지만 다음과 같이 생성할 수도 있다.
+
+{% highlight python %}
+torch.tensor([[1., -1.], [1., -1.]])
+
+''' output
+tensor([[ 1.0000, -1.0000],
+        [ 1.0000, -1.0000]])
+'''
+{% endhighlight %}
+<br><br>
+
+***
+## 3. Frequently Used Operations in PyTorch
+### Broadcasting
+서로 shape이 다른 tensor간의 연산을 할 때 자동으로 둘 중 더 작은 shape의 tensor를 더 shape이 큰 tensor의 shape으로 맞춰주어(broadcast) 계산해 주는 것을 말한다.
+<br><br>
+##### Same shape
+{% highlight python %}
+m1 = torch.FloatTensor([[3, 3]])
+m2 = torch.FloatTensor([[2, 2]])
+print(m1 + m2)
+
+''' output
+tensor([[5., 5.]])
+'''
+{% endhighlight %}
+
+같은 shape을 가지는 tensor 간의 연산은 위 코드의 결과처럼 같은 자리의 원소끼리 계산해 주면 된다.
+<br><br>
+##### Vector + Scalar
+{% highlight python %}
+m1 = torch.FloatTensor([[1, 2]])
+m2 = torch.FloatTensor([3]) # 3 -> [[3, 3]]
+print(m1 + m2)
+
+''' output
+tensor([[4., 5.]])
+'''
+{% endhighlight %}
+
+이번에는 vector와 scalar의 합이다. 이럴 때 `[3]`이 `[[3, 3]]`으로 **boradcast** 되어 shape을 동일하게 만든 후 연산을 진행하게 된다. 그래서 `[[1, 2]] + [[3, 3]]`의 결과인 `[[4, 5]]`가 나온다.
+<br><br>
+##### (2 x 1) Vector + (1 X 2) Vector
+{% highlight python %}
+m1 = torch.FloatTensor([[1, 2]]) # [[1, 2]] -> [[1, 2], [1, 2]]
+m2 = torch.FloatTensor([[3], [4]]) # [[3], [4]] -> [[3, 3], [4, 4]]
+print(m1 + m2)
+
+''' output
+tensor([[4., 5.],
+        [5., 6.]])
+'''
+{% endhighlight %}
+서로 shape이 다른 vector간의 연산의 경우에도 작은 차원을 큰 차원으로 맞춘 후 연산을 한다.
+
+위 코드에서는 `[[1, 2]]`이 `[[1, 2], [1, 2]]`로 `[[3], [4]]`가 `[[3, 3], [4, 4]]`로 각각 **broadcast**되어 연산을 진행하기 때문에 그 결과값은 `[[4, 5], [5, 6]]`이 나온다.
+<br><br>
+
+### Mul vs. Matmul
+둘다 tensor의 곱연산을 해 주며, 사용하는 형식도 `m1.matmul(m2)`, `m1.mul(m2)`로 동일하지만 차이점은 앞서 언급한 broadcasting 여부에 있다.
+{% highlight python %}
+# Without broadcasting
+m1 = torch.FloatTensor([[1, 2], [3, 4]])
+m2 = torch.FloatTensor([[1], [2]])
+print('Shape of Matrix 1: ', m1.shape) # 2 x 2
+print('Shape of Matrix 2: ', m2.shape) # 2 x 1
+print(m1.matmul(m2)) # 2 x 1
+
+# With broadcasting
+m1 = torch.FloatTensor([[1, 2], [3, 4]])
+m2 = torch.FloatTensor([[1], [2]])
+print('Shape of Matrix 1: ', m1.shape) # 2 x 2
+print('Shape of Matrix 2: ', m2.shape) # 2 x 1 ([[1], [2]]) -> 2 x 2 ([[1, 1], [2, 2]])
+print(m1 * m2) # 2 x 2
+print(m1.mul(m2))
+
+''' output
+Shape of Matrix 1:  torch.Size([2, 2])
+Shape of Matrix 2:  torch.Size([2, 1])
+tensor([[ 5.],
+        [11.]])
+Shape of Matrix 1:  torch.Size([2, 2])
+Shape of Matrix 2:  torch.Size([2, 1])
+tensor([[1., 2.],
+        [6., 8.]])
+tensor([[1., 2.],
+        [6., 8.]])
+'''
+{% endhighlight %}
+
+`matmul`의 경우 broadcasting 없이 행렬 곱셈을 한다. 그러므로 각 tonsor의 shape 변화 없이 그대로 곱한다. 
+
+반면 `mul`은 broadcasting을 하고 행렬의 각 원소들을 곱한다. 이 때문에 `m2`의 shape이 2 x 1에서 2 x 2로 `m1`의 shape에 맞춰진 후에 각 자리의 원소끼리 곱셈이 계산된 것을 확인할 수 있다.
+<br><br>
+
+### Mean
+평균을 계산해 준다.
+{% highlight python %}
+t = torch.FloatTensor([[1, 2], [3, 4]])
+print(t)
+
+''' output
+tensor([[1., 2.],
+        [3., 4.]])
+'''
+
+print(t.mean())
+print(t.mean(dim=0)) # 첫 번째 차원 평균
+print(t.mean(dim=1)) # 두 번째 차원 평균
+print(t.mean(dim=-1)) # 마지막 차원 평균
+
+''' output
+tensor(2.5000)
+tensor([2., 3.])
+tensor([1.5000, 3.5000])
+tensor([1.5000, 3.5000])
+'''
+{% endhighlight %}
+
+매개변수로 `dim`을 입력할 수 있다. 아무것도 입력하지 않은 경우에는 tonsor에 포함된 값 전체를, 차원을 지정해 준 경우 그 차원의 값들로 평균을 계산하여 tensor를 반환한다.
+
+`dim=0`이면 첫 번째 차원(세로)을 기준으로 평균을 계산하고, `dim=1`이면 두 번째 차원(가로)을, `dim=-1`이면 마지막 차원(여기선 두 번째 차원)을 기준으로 평균을 계산한다.
+<br><br>
+
+### Sum
+합을 계산해 준다. 평균과 기본적으로 사용법이 같다. 차이점은 결과값으로 합을 반환한다는 것.
+
+{% highlight python %}
+t = torch.FloatTensor([[1, 2], [3, 4]])
+print(t)
+
+''' output
+tensor([[1., 2.],
+        [3., 4.]])
+'''
+
+print(t.sum())
+print(t.sum(dim=0)) # 첫 번째 차원 합
+print(t.sum(dim=1)) # 두 번째 차원 합
+print(t.sum(dim=-1)) # 마지막 차원 합
+
+''' output
+tensor(10.)
+tensor([4., 6.])
+tensor([3., 7.])
+tensor([3., 7.])
+'''
+{% endhighlight %}
+<br><br>
+
+### Max and Argmax
+max는 최대값을 argmax는 최대값의 index를 의미한다.
+
+{% highlight python %}
+t = torch.FloatTensor([[1, 2], [3, 4]])
+print(t)
+
+''' output
+tensor([[1., 2.],
+        [3., 4.]])
+'''
+
+print(t.max()) # Returns one value: max
+
+''' output
+tensor(4.)
+'''
+{% endhighlight %}
+
+매개변수를 넣지 않으면 전체에서 최대값을 찾아 그 값을 반환한다.
+<br>
+
+{% highlight python %}
+print(t.max(dim=0)) # Returns two values: max and argmax (value amd index)
+print('Max: ', t.max(dim=0)[0])
+print('Argmax: ', t.max(dim=0)[1])
+
+''' output
+(tensor([3., 4.]), tensor([1, 1]))
+Max:  tensor([3., 4.])
+Argmax:  tensor([1, 1])
+'''
+
+print(t.max(dim=1)) 
+print(t.max(dim=-1))
+
+''' output
+(tensor([2., 4.]), tensor([1, 1]))
+(tensor([2., 4.]), tensor([1, 1]))
+'''
+{% endhighlight %}
+`dim`을 지정하면 해당 차원에서의 최대값과 그 차원에서 최대값의 위치를 tuple 형태로 반환한다.
+
+위의 경우 `dim=0`(첫 번째 차원 - 열)을 기준으로 최대값인 3, 4와 그 값들의 index인 1, 1이 반환되는 것을 확인할 수 있다.
+
+`dim=1`인 경우에도 기준이 되는 차원만 달라지고 같은 방식으로 `(max, argmax)`를 반환한다.
+
+만약 argmax 값만 필요하다면 아래와 같이 `torch.argmax()`를 사용하여 값을 얻을 수 있다.
+{% highlight python %}
+print(t.argmax(dim=0)) 
+print(t.argmax(dim=1)) 
+print(t.argmax(dim=-1))
+
+''' output
+tensor([1, 1])
+tensor([1, 1])
+tensor([1, 1])
+'''
+{% endhighlight %}
+<br><br>
+
+### View
+numpy의 reshape과 같은 역할을 한다.
+{% highlight python %}
+t = np.array([[[0, 1, 2],
+               [3, 4, 5]],
+
+              [[6, 7, 8],
+               [9, 10, 11]]])
+ft = torch.FloatTensor(t)
+print(ft.shape)
+
+''' output
+torch.Size([2, 2, 3])
+'''
+
+print(ft.view([-1, 3]))
+print(ft.view([-1, 3]).shape)
+
+''' output
+tensor([[ 0.,  1.,  2.],
+        [ 3.,  4.,  5.],
+        [ 6.,  7.,  8.],
+        [ 9., 10., 11.]])
+'''
+
+# -1은 보통 가장 변동이 심한 batch size 등(계산 실수가 많이 일어날 만한 곳)에 사용
+# view(reshape) 하려는 결과 차원의 곱이 처음 차원들의 곱과 같아야 사용 가능
+print(ft.view([-1, 1, 3]))
+print(ft.view([-1, 1, 3]).shape)
+
+''' output
+tensor([[[ 0.,  1.,  2.]],
+
+        [[ 3.,  4.,  5.]],
+
+        [[ 6.,  7.,  8.]],
+
+        [[ 9., 10., 11.]]])
+'''
+{% endhighlight %}
+shape이 `[2, 2, 3]`인 tensor를 다른 shape들로 변경하는 예제이다.
+
+이때 주의할 점은 shape을 변경할 대상과 변경한 후의 shape의 각 차원의 곱이 같아야 한다는 것이다. 위와 같이 shape이 `[2, 2, 3]`이라면 변경된 이후의 차원들의 곱도 2x2x3 = 12여야 한다.
+
+많은 경우 위와 같이 한 차원에 -1을 넣어 차원을 자동으로 맞춰주도록 하는데, 보통 변동이 가장 심한 batch size 등에 -1을 적용하여 사용한다.
+
+이렇게 사용하는 까닭은 변동이 심하거나 값이 큰 경우 매번 계산하는 것이 불편하기도 하고 계산하는 과정에서 실수가 발생할 수도 있기 때문이다.
+<br><br>
+
+### Squeeze
+걸레를 짜서 물을 빼내는 것과 같이 차원이 1인 것을 모두 삭제해 준다.
+{% highlight python %}
+ft = torch.FloatTensor([[0], [1], [2]])
+print(ft)
+print(ft.shape)
+
+''' output
+tensor([[0.],
+        [1.],
+        [2.]])
+torch.Size([3, 1])
+'''
+
+# 1이 있는 차원을 삭제
+# dim=? 에 값을 넣을 경우 해당 차원이 1이면 삭제
+print(ft.squeeze())
+print(ft.squeeze().shape)
+
+''' output
+tensor([0., 1., 2.])
+torch.Size([3])
+'''
+{% endhighlight %}
+위와 같이 차원이 1아면 삭제해 준다. `dim=?`도 설정해 줄 수 있는데, 이 경우 해당 차원이 1이면 삭제한다. 예제와 같은 tensor의 경우 `dim=1`일 때 동일한 결과를 보여준다.
+<br>
+### Unsqueeze
+`squeeze`의 반대이다. 차원을 명시하여 그 차원을 1로 만들어 준다.
+{% highlight python %}
+ft = torch.Tensor([0, 1, 2])
+print(ft.shape)
+
+''' output
+torch.Size([3])
+'''
+# 차원(dim)을 명시하여 그 차원을 1로 만들어줌
+print(ft.unsqueeze(0))
+print(ft.unsqueeze(0).shape)
+
+print(ft.unsqueeze(1))
+print(ft.unsqueeze(1).shape)
+
+''' output
+tensor([[0., 1., 2.]])
+torch.Size([1, 3])
+
+tensor([[0.],
+        [1.],
+        [2.]])
+torch.Size([3, 1])
+'''
+{% endhighlight %}
+지정한 차원을 1로 만들어 주는 것을 볼 수 있다.
+{% highlight python %}
+print(ft.view(1, -1))
+print(ft.view(1, -1).shape)
+
+print(ft.view(-1, 1))
+print(ft.view(-1, 1).shape)
+
+''' output
+tensor([[0., 1., 2.]])
+torch.Size([1, 3])
+
+tensor([[0.],
+        [1.],
+        [2.]])
+torch.Size([3, 1])
+'''
+{% endhighlight %}
+view를 이용해서 같은 결과를 만들 수도 있다.
+<br><br>
+
+### Casting
+tensor의 형을 변환시켜주는 것을 말한다.
+{% highlight python %}
+# 텐서의 형변환
+t = torch.LongTensor([1, 2, 3, 4])
+print(lt)
+
+''' output
+tensor([1, 2, 3, 4])
+'''
+
+print(lt.float())
+
+''' output
+tensor([1., 2., 3., 4.])
+'''
+{% endhighlight %}
+
+위와 같이 `tensor.float()`으로 실수형 변환을 할 수 있고
+
+{% highlight python %}
+bt = torch.ByteTensor([True, False, False, True])
+print(bt)
+
+''' output
+tensor([1, 0, 0, 1], dtype=torch.uint8)
+'''
+
+print(bt.long())
+print(bt.float())
+
+''' output
+tensor([1, 0, 0, 1])
+tensor([1., 0., 0., 1.])
+'''
+{% endhighlight %}
+
+이처럼 torch의 다른 타입들로도 변환이 가능하다.
+<br><br>
+
+### Concatenation
+tensor들을 이어붙인다.
+
+{% highlight python %}
+x = torch.FloatTensor([[1, 2], [3, 4]])
+y = torch.FloatTensor([[5, 6], [7, 8]])
+
+# 주어진 차원이 늘어남 (이어 붙임)
+print(torch.cat([x, y], dim=0))
+print(torch.cat([x, y], dim=1))
+
+''' output
+tensor([[1., 2.],
+        [3., 4.],
+        [5., 6.],
+        [7., 8.]])
+tensor([[1., 2., 5., 6.],
+        [3., 4., 7., 8.]])
+'''
+{% endhighlight %}
+
+이 때 차원을 지정해 주면 그 차원으로 tensor를 잇는다. default는 `dim=0`
+<br><br>
+
+### Stacking
+`cat`과 비슷하지만 데이터의 차원은 유지하면서 쌓는다는 개념이 `cat`의 이어븥인다는 개념과는 조금 다르다.
+
+{% highlight python %}
+x = torch.FloatTensor([1, 4])
+y = torch.FloatTensor([2, 5])
+z = torch.FloatTensor([3, 6])
+
+
+print(torch.stack([x, y, z]))
+print(torch.stack([x, y, z], dim=1))
+
+''' output
+tensor([[1., 4.],
+        [2., 5.],
+        [3., 6.]])
+tensor([[1., 2., 3.],
+        [4., 5., 6.]])
+'''
+{% endhighlight %}
+
+마찬가지로 stack하는 방향을 `dim`으로 조절해 줄 수 있다.
+
+또한, 이 과정은 `unsqueeze`와 `cat`의 조합으로 똑같이 진행할 수 있다.
+
+{% highlight python %}
+# torch.cat([(1, 2), (1, 2), (1, 2)], dim=0) -> (3, 2) (stacking과 동일)
+print(torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=0))
+
+''' output
+tensor([[1., 4.],
+        [2., 5.],
+        [3., 6.]])
+'''
+{% endhighlight %}
+
+#### cat vs. stack
+cat 과 stack이 조금 헷갈려서 차이점을 정리해볼까 한다.
+
+결과값들의 shape을 비교해 보면 조금 더 차이점을 알기 쉽다.
+
+{% highlight python %}
+x = torch.FloatTensor([[1, 2], [3, 4]])
+y = torch.FloatTensor([[5, 6], [7, 8]])
+
+print(x.shape, y.shape)
+print(torch.cat([x, y], dim=0).shape)
+print(torch.cat([x, y], dim=1).shape)
+
+x = torch.FloatTensor([1, 4])
+y = torch.FloatTensor([2, 5])
+z = torch.FloatTensor([3, 6])
+
+print(x.shape, y.shape, z.shape)
+print(torch.stack([x, y, z]).shape)
+print(torch.stack([x, y, z], dim=1).shape)
+
+''' output
+torch.Size([2, 2]) torch.Size([2, 2])
+torch.Size([4, 2])
+torch.Size([2, 4]
+
+torch.Size([2]) torch.Size([2]), torch.Size([2]
+torch.Size([3, 2])
+torch.Size([2, 3])
+'''
+{% endhighlight %}
+
+![](/posting_imgs/lab1-4.jpg)
+
+코드의 결과와 그림을 함께 보자.
+
+concat의 경우 말 그대로 이어 붙이는 것이기 때문에 지정해 준 차원의 길이가 각 tensor의 차원 길이 만큼 늘어났다. 하지만 차원의 개수 변화는 없다. 
+반면, stack은 새로운 차원의 방향으로 쌓는 과정이기 때문에 tensor 간의 shape이 같아야 하고 차원이 하나 더 늘어난다. 그리고 그 차원의 크기는 쌓으려는 텐서의 개수와 같다.
+
+다시 정리해 보면 conact은 데이터를 그대로 잇는 것, stack은 새로운 차원으로 쌓는 것이라는 차이점이 있다.
+<br><br>
+
+### Ones and Zeros Like
+해당 tensor와 같은 shape의 1 또는 0으로 채워진 tensor를 만든다.
+
+{% highlight python %}
+x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]])
+print(x)
+
+''' output
+tensor([[0., 1., 2.],
+        [2., 1., 0.]])
+'''
+
+# device도 같게 선언됨
+print(torch.ones_like(x))
+print(torch.zeros_like(x))
+
+''' output
+tensor([[1., 1., 1.],
+        [1., 1., 1.]])
+tensor([[0., 0., 0.],
+        [0., 0., 0.]])
+'''
+{% endhighlight %}
+
+이렇게 생성된 tensor는 shape 뿐만 아니라 device도 같게 생성된다. 즉, 바로 기존의 tensor와 연산이 가능하다.
+<br><br>
+
+### In-place Operation
+선언 없이 바로 결과값으로 대체한다. 사용법은 연산자에 `_`를 붙이면 된다. 
+
+{% highlight python %}
+print(x.mul(2.))
+print(x)
+# 선언 없이 바로 대체
+print(x.mul_(2.))
+print(x)
+
+''' output
+tensor([[2., 4.],
+        [6., 8.]])
+tensor([[1., 2.],
+        [3., 4.]])
+tensor([[2., 4.],
+        [6., 8.]])
+tensor([[2., 4.],
+        [6., 8.]])
+'''
+{% endhighlight %}
+
+선언하는 과정을 생략할 수 있다는 장점이 있지만 PyTorch의 gc가 잘 설계되어 있어서 속도면의 이점은 크게 없을 수도 있다고 한다.
\ No newline at end of file
diff --git a/_posts/2022-04-17-dlZeroToAll-PyTorch-2.markdown b/_posts/2022-04-17-dlZeroToAll-PyTorch-2.markdown
new file mode 100644
index 00000000000..be171b19187
--- /dev/null
+++ b/_posts/2022-04-17-dlZeroToAll-PyTorch-2.markdown
@@ -0,0 +1,224 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab2: Linear regression"
+author: Kwon
+date: 2022-04-17T16:00:00+0900
+categories: [pytorch, study]
+tags: [linear-regressoin]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 2: Linear regression 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## Theoretical Overview
+
+### Hypothesis (가설)
+선형 회귀에서 사용하는 1차 방정식을 말한다. weight와 bias를 계속 바꿔가면거 마지막 학습이 끝난 뒤의 최종값을 사용하여 데이터를 예측한다. 수식은 다음과 같다.
+
+\\[ H(x) = Wx + b \\]
+
+최종 결과로 나온 가설을 model이라 하고 '학습되었다'고 한다.
+
+### Cost
+model의 예측 값이 실제 값과 얼마나 다른 지를 알려준다. (작을수록 좋은 모델이다.)
+
+여기서는 아래와 같은 MSE(Mean Square Error)를 사용한다.
+
+\\[ MSE = cost(W, b) = \frac{1}{m} \sum^m_{i=1} \left( H(x^{(i)}) - y^{(i)} \right)^2 \\]
+
+***
+## Import
+{% highlight python %}
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+{% endhighlight %}
+
+***
+## Data
+데이터는 다음과 같이 간단한 공부 시간 - 성적 데이터 셋을 사용한다.
+
+| 공부 시간 | 성적 |
+|:----:|:----:|
+|1|1|
+|2|2|
+|3|3|
+{:.inner-borders}
+
+{% highlight python %}
+x_train = torch.FloatTensor([[1], [2], [3]])
+y_train = torch.FloatTensor([[1], [2], [3]])
+{% endhighlight %}
+
+공부 시간이 각각 1시간에서 3시간일 때 그 점수도 1시간에서 3시간인 데이터 셋이다.
+
+이런 데이터셋일 때 가장 이상적인 회귀선을 한번 생각해 보자.
+
+![](/posting_imgs/lab2-1.png)
+
+위와 같은 $ y = x $ 꼴의 직선이 가장 이상적일 것이다. 그러므로 이후 학습을 진행할 때 weight=1, bias=0에 가까워 지는지 확인하면 학습이 잘 이루어지고 있는지 알 수 있을 것이다.
+
+***
+## Weight Initialization
+
+{% highlight python %}
+W = torch.zeros(1, requires_grad=True)
+print(W)
+b = torch.zeros(1, requires_grad=True)
+print(b)
+
+''' output
+tensor([0.], requires_grad=True)
+tensor([0.], requires_grad=True)
+'''
+{% endhighlight %}
+
+학습할 weight와 bias를 모두 0으로 초기화 해 준다.
+
+***
+## Hypothesis
+\\[ H(x) = Wx + b \\]
+
+앞서 보았던 Hypothesis 식에 따라 초기화해 준다.
+
+{% highlight python %}
+hypothesis = x_train * W + b
+print(hypothesis)
+
+''' output
+tensor([[0.],
+        [0.],
+        [0.]], grad_fn=<AddBackward0>)
+'''
+{% endhighlight %}
+
+초기 weight와 bias는 모두 0이므로 모든 값이 0으로 나온 것을 볼 수 있다.
+
+***
+## Cost
+\\[ MSE = cost(W, b) = \frac{1}{m} \sum^m_{i=1} \left( H(x^{(i)}) - y^{(i)} \right)^2 \\]
+
+Cost도 마찬가지로 앞서 나온 식에 맞춰 정의해 준다.
+
+{% highlight python %}
+cost = torch.mean((hypothesis - y_train) ** 2)
+print(cost)
+
+''' output
+tensor(4.6667, grad_fn=<MeanBackward1>)
+'''
+{% endhighlight %}
+
+***
+## Gradient Descent
+`optim`을 통해 SGD optimer를 불러 사용한다. Gradient Descent에 대한 내용은 다음 포스팅에서 더 자세하게 살펴 볼 예정이다.
+
+{% highlight python %}
+optimizer = optim.SGD([W, b], lr=0.01)
+{% endhighlight %}
+
+그리고 PyTorch에서 학습을 할 때 항상 묶어 쓰는 코드들이 있다.
+
+{% highlight python %}
+optimizer.zero_grad() # gradient 초기화
+cost.backward()       # gradient 계산
+optimizer.step()      # 계산된 gradient를 따라 W, b를 개선
+
+print(W)
+print(b)
+
+''' output
+tensor([0.0933], requires_grad=True)
+tensor([0.0400], requires_grad=True)
+'''
+{% endhighlight %}
+
+위 3개의 코드는 gradient를 초기화 하고, cost에 따라 계산하고, 그 결과에 따라 weight와 bias를 개선하는 과정이다. 학습할 때 필요한 부분이므로 외워두어야 한다.
+
+gradient를 계산할 때 각 시행마다 `optimizer.zero_grad()`로 gradient를 초기화하는 이유는 `cost.backward()`가 계산을 하고 기존 gradient를 대체하는 것이 아니라 더하기 때문이라고 한다.(DNN에서의 backpropagation을 할 때 유용하기 때문)
+그래서 `optimizer.zero_grad()`를 통해 초기화해 주지 않으면 전 시행의 gradient와 현재의 것이 누적되어 잘못된 방향으로 학습되게 된다.
+
+위 코드를 한 번 실행한 것이 한 번 학습한 것과 같다. 그 결과에 따라 weight와 bias의 개선이 이루어진 것을 볼 수 있다.
+
+개선된 weight와 bias로 다시 예측을 해 보면, 다음과 같은 값을 얻을 수 있다.
+
+{% highlight python %}
+hypothesis = x_train * W + b
+print(hypothesis)
+
+cost = torch.mean((hypothesis - y_train) ** 2)
+print(cost)
+
+''' output
+tensor([[0.1333],
+        [0.2267],
+        [0.3200]], grad_fn=<AddBackward0>)
+
+tensor(3.6927, grad_fn=<MeanBackward0>)
+'''
+{% endhighlight %}
+
+기존에 0이었던 값들이 실제 값에 가깝게 변했고, cost도 줄어든 것을 확인할 수 있다.
+
+***
+## Training with Full Code
+{% highlight python %}
+# 데이터
+x_train = torch.FloatTensor([[1], [2], [3]])
+y_train = torch.FloatTensor([[1], [2], [3]])
+# 모델 초기화
+W = torch.zeros(1, requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+# optimizer 설정
+optimizer = optim.SGD([W, b], lr=0.01)
+
+nb_epochs = 1000
+for epoch in range(nb_epochs + 1):
+    
+    # H(x) 계산
+    hypothesis = x_train * W + b
+    
+    # cost 계산
+    cost = torch.mean((hypothesis - y_train) ** 2)
+
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    # 100번마다 로그 출력
+    if epoch % 100 == 0:
+        print('Epoch {:4d}/{} W: {:.3f}, b: {:.3f} Cost: {:.6f}'.format(
+            epoch, nb_epochs, W.item(), b.item(), cost.item()
+        ))
+
+''' output
+Epoch    0/1000 W: 0.093, b: 0.040 Cost: 4.666667
+Epoch  100/1000 W: 0.873, b: 0.289 Cost: 0.012043
+Epoch  200/1000 W: 0.900, b: 0.227 Cost: 0.007442
+Epoch  300/1000 W: 0.921, b: 0.179 Cost: 0.004598
+Epoch  400/1000 W: 0.938, b: 0.140 Cost: 0.002842
+Epoch  500/1000 W: 0.951, b: 0.110 Cost: 0.001756
+Epoch  600/1000 W: 0.962, b: 0.087 Cost: 0.001085
+Epoch  700/1000 W: 0.970, b: 0.068 Cost: 0.000670
+Epoch  800/1000 W: 0.976, b: 0.054 Cost: 0.000414
+Epoch  900/1000 W: 0.981, b: 0.042 Cost: 0.000256
+Epoch 1000/1000 W: 0.985, b: 0.033 Cost: 0.000158
+'''
+{% endhighlight %}
+
+1000 Epoch 학습하는 전체 코드이다. 로그에서 알 수 있듯이 cost는 점점 줄어들고 weight와 bias도 우리가 예상했던 회귀선의 것과 비슷해졌다.
+
+{% highlight python %}
+x_train * W + b
+
+''' output
+tensor([[1.0186],
+        [2.0040],
+        [2.9894]], grad_fn=<AddBackward0>)
+'''
+{% endhighlight %}
+
+실제로 학습된 모델로 예측을 해 보면 실제 값과 아주 비슷하게 나온 것을 확인할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-04-18-dlZeroToAll-PyTorch-3.markdown b/_posts/2022-04-18-dlZeroToAll-PyTorch-3.markdown
new file mode 100644
index 00000000000..7db2293b28f
--- /dev/null
+++ b/_posts/2022-04-18-dlZeroToAll-PyTorch-3.markdown
@@ -0,0 +1,217 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab3: Minimizing Cost"
+author: Kwon
+date: 2022-04-18T14:00:00+0900
+categories: [pytorch, study]
+tags: [linear-regressoin, cost, gradient-descent]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 3: Minimizing Cost 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## Theoretical Overview
+이번에는 Grdient descent에 대해 조금 더 집중적으로 알아보기 위해 Hypothesis를 조금 더 단순하게 $ H(x) = Wx $로 바꾸어 살펴보자.
+
+cost는 똑같이 MSE(Mean Square Error)를 사용하고 데이터도 이전과 같은 공부 시간 - 성적 데이터를 사용한다. ([Lab2 포스팅 참조](/posts/dlZeroToAll-PyTorch-2/))
+
+\\[ MSE = cost(W) = \frac{1}{m} \sum^m_{i=1} \left( H(x^{(i)}) - y^{(i)} \right)^2 \\]
+
+***
+
+## Import
+{% highlight python %}
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+{% endhighlight %}
+
+***
+## Cost by W
+W의 변화에 따른 cost 그래프를 그려보면 다음과 같은 2차 곡선이 그려진다. 그러므로 cost가 가장 작은 점은 기울기(미분값)가 0인 극소점이다.
+
+{% highlight python %}
+W_l = np.linspace(-5, 7, 1000)
+cost_l = []
+for W in W_l:
+    hypothesis = W * x_train
+    cost = torch.mean((hypothesis - y_train) ** 2)
+
+    cost_l.append(cost.item())
+
+plt.plot(W_l, cost_l)
+plt.xlabel('$W$')
+plt.ylabel('Cost')
+plt.show()
+{% endhighlight %}
+![](/posting_imgs/lab3-1.png)
+<br>
+
+***
+## Gradient Descent by Hand
+cost가 가장 작은 점을 찾는 것이 우리의 목표인데, 이것을 cost의 미분값을 이용하는 방식으로 달성하려고 한다.
+
+cost는 다음과 같으므로
+<br><br>
+\\[ MSE = cost(W) = \frac{1}{m} \sum^m_{i=1} \left( H(x^{(i)}) - y^{(i)} \right)^2 \\]
+
+$W$에 대해 미분하면 아래와 같은 결과를 얻을 수 있다.
+
+\\[ \nabla W = \frac{\partial cost}{\partial W} = \frac{2}{m} \sum^m_{i=1} \left( Wx^{(i)} - y^{(i)} \right)x^{(i)} \\]
+
+이렇게 구한 gradient는 다음 식과 같이 학습에 적용하게 된다.
+
+\\[ W := W - \alpha \nabla W \,\,\left(\alpha = learning\,\,rate\right)\\]
+
+이런 형태로 학습을 하는 이유를 한번 알아보자.
+<br><br>
+아래의 두 gif는 각각 극소점의 좌우에서 극소점에 접근할 때 접선의 변화를 나타낸 것이다.
+<br><br>
+![](/posting_imgs/lab3-2.gif)
+<br><br>
+먼저 왼쪽에서 접근하는 경우 기울기(gradient)가 음수이고 극소점으로 도달하기 위해서는 $W$가 커져야 한다. 그러므로 음수인 기울기를 빼주어 극소점에 가깝게 도달할 수 있다.
+<br><br>
+![](/posting_imgs/lab3-3.gif)
+<br><br>
+다음으로 오른쪽에서 접근하는 경우 기울기가 양수이고 극소점으로 도달하기 위해서는 $W$가 작아져야 한다. 이 때는 양수인 기울기를 빼주어 극소점에 가깝게 도달할 수 있다.
+
+결국 이 둘다 빼야하므로 모두 만족하는 식이 $ W := W - \alpha \nabla W $, 기울기의 뺄셈으로 주어지는 것이다. 이 때 $learning\,\,rate$인 $\alpha$는 말 그대로 학습률(한 번에 학습을 얼마나 할 것인가)을 나타내는 것이므로 상황에 맞게 최적화 하여 사용한다.
+
+다만, 학습률이 너무 작으면 수렴이 늦어지고, 너무 크면 진동하면 발산해 버리기 때문에 적절한 범위의 값을 사용해야 한다.
+
+![](/posting_imgs/lab3-4.jpg)
+
+이어서 앞선 식들을 코드로 표현하면 다음과 같다.
+
+\\[ \nabla W = \frac{\partial cost}{\partial W} = \frac{2}{m} \sum^m_{i=1} \left( Wx^{(i)} - y^{(i)} \right)x^{(i)} \\]
+
+{% highlight python %}
+gradient = torch.sum((W * x_train - y_train) * x_train)
+print(gradient)
+
+''' output
+tensor(-14.)
+'''
+{% endhighlight %}
+
+\\[ W := W - \alpha \nabla W \,\,\left(\alpha = learning\,\,rate\right)\\]
+
+{% highlight python %}
+lr = 0.1
+W -= lr * gradient
+print(W)
+
+''' output
+tensor(1.4000)
+'''
+{% endhighlight %}
+
+***
+## Training
+앞서 구현했던 것들을 활용하여 실제로 학습하는 코드를 작성해 보면 다음과 같다.
+
+{% highlight python %}
+# 데이터
+x_train = torch.FloatTensor([[1], [2], [3]])
+y_train = torch.FloatTensor([[1], [2], [3]])
+# 모델 초기화
+W = torch.zeros(1)
+# learning rate 설정
+lr = 0.1
+
+nb_epochs = 10
+for epoch in range(nb_epochs + 1):
+
+    # H(x) 계산
+    hypothesis = x_train * W
+
+    # cost gradient 계산
+    cost = torch.mean((hypothesis - y_train) ** 2)
+    gradient = torch.sum((W * x_train - y_train) * x_train)
+
+    print('Epoch {:4d}/{} W: {:.3f}, Cost: {:.6f}'.format(
+        epoch, nb_epochs, W.item(), cost.item()
+    ))
+
+    # gradient로 H(x) 개선
+    W -= lr * gradient
+
+''' output
+Epoch    0/10 W: 0.000, Cost: 4.666667
+Epoch    1/10 W: 1.400, Cost: 0.746666
+Epoch    2/10 W: 0.840, Cost: 0.119467
+Epoch    3/10 W: 1.064, Cost: 0.019115
+Epoch    4/10 W: 0.974, Cost: 0.003058
+Epoch    5/10 W: 1.010, Cost: 0.000489
+Epoch    6/10 W: 0.996, Cost: 0.000078
+Epoch    7/10 W: 1.002, Cost: 0.000013
+Epoch    8/10 W: 0.999, Cost: 0.000002
+Epoch    9/10 W: 1.000, Cost: 0.000000
+Epoch   10/10 W: 1.000, Cost: 0.000000
+'''
+{% endhighlight %}
+
+**Hypothesis output 계산 -> cost와 gradient 계산 -> gradient로 hypothesis(weight) 개선**
+
+위와 같은 순서로 총 10 epoch 학습하는 코드이다. 학습을 한번 할 때마다 cost가 줄어들고, 우리가 생각한 이상적인 $W$인 1에 점점 가까워지는 것을 확인할 수 있다.
+
+***
+## Training with `optim`
+
+**Training**에서 했던 것처럼 우리가 gradient를 계산하는 코드를 직접 작성하여 사용할 수도 있지만 PyTorch에서 제공하는 `optim`을 이용하여 간단하게 구현할 수도 있다.
+
+{% highlight python %}
+# 데이터
+x_train = torch.FloatTensor([[1], [2], [3]])
+y_train = torch.FloatTensor([[1], [2], [3]])
+# 모델 초기화
+W = torch.zeros(1, requires_grad=True)
+# optimizer 설정
+optimizer = optim.SGD([W], lr=0.15)
+
+nb_epochs = 10
+for epoch in range(nb_epochs + 1):
+
+    # H(x) 계산
+    hypothesis = x_train * W
+
+    # cost 계산
+    cost = torch.mean((hypothesis - y_train) ** 2)
+
+    print('Epoch {:4d}/{} W: {:.3f} Cost: {:.6f}'.format(
+        epoch, nb_epochs, W.item(), cost.item()
+    ))
+
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+''' output
+Epoch    0/10 W: 0.000 Cost: 4.666667
+Epoch    1/10 W: 1.400 Cost: 0.746667
+Epoch    2/10 W: 0.840 Cost: 0.119467
+Epoch    3/10 W: 1.064 Cost: 0.019115
+Epoch    4/10 W: 0.974 Cost: 0.003058
+Epoch    5/10 W: 1.010 Cost: 0.000489
+Epoch    6/10 W: 0.996 Cost: 0.000078
+Epoch    7/10 W: 1.002 Cost: 0.000013
+Epoch    8/10 W: 0.999 Cost: 0.000002
+Epoch    9/10 W: 1.000 Cost: 0.000000
+Epoch   10/10 W: 1.000 Cost: 0.000000
+'''
+{% endhighlight %}
+
+`optim.SGD`가 우리가 만들어서 구현했던 gradient에 대한 처리를 해주고 있는 것을 볼 수 있다.
+{% highlight python %}
+optimizer.zero_grad() # gradient 초기화
+cost.backward()       # gradient 계산
+optimizer.step()      # 계산된 gradient를 따라 W, b를 개선
+{% endhighlight %}
+저번 강의에서도 등장했던 위 3개의 묶음 코드를 통해 gradient에 대한 계산과 그에 따른 학습이 이루어지고 있다.
+
+이 때도 마찬가지로 $W$와 cost를 보면 잘 학습이 되는 것을 볼 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-04-26-entropy.markdown b/_posts/2022-04-26-entropy.markdown
new file mode 100644
index 00000000000..ccafd71aa54
--- /dev/null
+++ b/_posts/2022-04-26-entropy.markdown
@@ -0,0 +1,60 @@
+---
+title: "Entropy(엔트로피)란?"
+author: Kwon
+date: 2022-04-26T14:40:00+0900
+categories: [background]
+tags: [entropy]
+math: true
+mermaid: false
+---
+
+### Related Post
+
+1. **Entropy**
+2. [KL Divergence](/posts/KL-divergence/)
+3. [Cross Entropy](/posts/cross-entropy/)
+
+***
+오토인코더에 대한 공부를 하다가 entropy, cross entropy, KL divergence 등 모르는 용어들이 있어서 더 이상 미루지 않고 공부를 해 보기로 했다.
+
+***
+## Entropy
+
+엔트로피의 정의는 일반적인 용어냐, 과학 용어냐 등에 따라 달라질 수 있지만 이번에 다뤄 볼 엔트로피는 정보 엔트로피이다.
+
+정보이론에서의 엔트로피란 각 정보에 포함된 기댓값(평균 정보량), 정보의 불확실량등으로 설명할 수 있지만 내가 여러 자료들을 찾아보면서 머신러닝의 관점에서 가장 와닿았던 의미는 **예측하기 어려운 정도**였다.
+
+그럼 엔트로피가 무엇이길래 이렇게 다양한 의미로 해석될 수 있는지, 그리고 내가 왜 **예측하기 어려운 정도**를 가장 와닿게 느낀 것인지 한번 알아보자.
+
+먼저 정보량이라는 것을 알아야 한다. 정보량은 정보를 정량화 한 것으로 그 정보에 대한 가치를 나타낸다고 볼 수 있다.
+
+예를 들어 여기 두가지의 정보가 있다. 
+
+> 다이아몬드는 딱딱하다.
+
+> 다이아몬드가 가장 많이 묻혀 있는 광산은 러시아에 있다.
+
+위 두 정보 중 어느 것이 더 가치가 높은 정보일까 한번 생각해보자. 다이아몬드가 딱딱하다는 것은 대부분의 사람이 알고 있는 사실이므로 정보로서의 가치가 낮다고 할 수 있다. 하지만 다이아몬드가 가장 많이 묻혀 있는 광산이 어디에 있는지는 대부분의 사람이 아는 정보가 아니므로 상대적으로 가치가 높다고 할 수 있다.
+
+즉, **정보량**은
+* 당연한 사실일수록 낮다.
+* 그 정보가 불확실할수록 높다.
+* 완전히 예측 가능하면 가치가 없다.
+
+결국, 발생 확률이 적을수록 정보의 가치는 올라가게 된다. 그러므로 정보량을 정의할 때에는 확률과 반비례의 관계를 가지도록 하는 것이 좋을 것이다.
+이러한 이유로 정보량은 다음과 같이 정의된다.
+
+\\[ I\left(x\right) = -\log_b{ P\left( x\right ) } \\]
+
+어떤 사건이 일어난 확률의 역수에 로그를 취한 형태이다. 여기서 로그를 취한 이유는 두 사건의 정보량을 합친 것이 각 사건의 정보량을 더한 것과 같아야 하기 때문이다 (로그는 곱을 합으로 바꿀 수 있다).
+이 때 밑 $b$는 사용처에 따라 2, 10, $e$를 많이 사용한다.
+
+정보량까지 정의를 했으니 엔트로피를 정의할 차례이다. 앞서 엔트로피는 정보량의 기댓값이라고 하였다. 즉 각 사건에 대한 확률과 정보량의 곱을 모두 합한 것으로 정의할 수 있다.
+
+\\[ H\left(x\right) = E\left( I\left ( x\right ) \right) = -\sum^n_{i=1} p\left( x_i \right) \log_b{ p\left( x_i\right ) } \\]
+
+엔트로피는 정보량이 클수록 커지는 성질을 가진다. 다른 정보이론에서는 모르겠지만 머신러닝 분야에서는 예측을 하는 것이 목적이므로 예측에 맞춰 다시 말을 정리하면, **예측이 힘들수록 더 크다**는 것이 된다.
+
+이것이 앞서 **예측하기 어려운 정도**가 가장 와닿았다고 하는 이유였다.
+
+다음 포스팅에서는 이 엔트로피를 이용한 대표적인 loss인 cross entropy를 알아보기 위해 KL divergence에 대해 먼저 알아보려 한다.
diff --git a/_posts/2022-04-27-KL-divergence.markdown b/_posts/2022-04-27-KL-divergence.markdown
new file mode 100644
index 00000000000..bd784438480
--- /dev/null
+++ b/_posts/2022-04-27-KL-divergence.markdown
@@ -0,0 +1,58 @@
+---
+title: "KL divergence(쿨백-라이블러 발산)"
+author: Kwon
+date: 2022-04-27T00:00:00+0900
+categories: [background]
+tags: [entropy, kl-divergence]
+math: true
+mermaid: false
+---
+
+### Related Post
+
+1. [Entropy](/posts/entropy/)
+2. **KL Divergence**
+3. [Cross Entropy](/posts/cross-entropy/)
+
+***
+
+이번에는 엔트로피에 이어 쿨백-라이블러 발산(Kullback-Leibler divergence)에 대해 알아보려 한다.
+
+***
+## Kullback-Leibler divergence, KLD
+
+쿨백-라이블러 발산은 어떤 두 확률분포의 차이를 계산하기 위한 함수로, 두 확률분포의 [정보 엔트로피](/posts/entropy/)의 차이를 계산한다.
+
+의미적으로는 확률분포 $P$가 있을 때 그 분포를 근사적으로 표현하는 $Q$를 $P$ 대신 이용하여 샘플링 할 경우 엔트로피의 변화를 의미한다.
+
+시각적으로도 한번 확인해 보자. 
+여기 확률분포 $P$(파란색)와 $Q$(초록색)가 있다. 그리고 두 확률분포에 대한 엔트로피 차이를 계산하여 표현한 곡선(빨간색)을 볼 수 있다.
+
+![](/posting_imgs/kl-1.jpg)
+
+그래프에서 확인할 수 있듯이 (당연하게도) 분포간의 차이가 큰 곳에서는 엔트로피의 차이가 크고 차이가 적은 곳에서는 줄어든다. 심지어 두 확률분포의 교점(점선)에서는 값이 같기 때문에 엔트로피의 차이도 0이 되는 것을 확인할 수 있다.
+
+이제 수식으로도 한번 표현해 보자.
+$P$의 엔트로피는 다음과 같고
+
+\\[ H\left( P \right)= -\sum^n_{i=1} p\left( x_i \right) \log{ p\left( x_i\right ) } \\]
+
+$P$대신 $Q$를 사용하여 샘플링할 경우 엔트로피는 다음과 같이 정의된다. ($Q$의 정보량에 대한 기댓값)
+
+\\[ H\left( P, Q \right)= -\sum^n_{i=1} p\left( x_i \right) \log{ q\left( x_i\right ) } \\]
+
+쿨백-라이블러는 이들의 차이라고 했으므로 다음과 같이 정의할 수 있다.
+
+$ KL\left( P\|\|Q \right) = H\left( P, Q \right) - H\left( P \right) $
+$ = \left( -\sum^n_{i=1} p\left( x_i \right) \log{ q\left( x_i\right ) } \right) - \left( -\sum^n_{i=1} p\left( x_i \right) \log{ p\left( x_i\right ) } \right) $
+\\[ = -\sum^n_{i=1} p\left( x_i \right) \log{ \frac{ q\left( x_i\right )}{ p\left( x_i\right ) } } \\]
+
+이때 이산확률분포의 쿨백-라이블러 발산은 위에서 표현한 것과 같이 총 합으로 나타낼 수 있으며 다음과 같고
+
+\\[ KL\left( P\|\|Q \right) = \sum_i P\left( i \right) \log{ \frac{ P\left( i \right )}{ Q\left( i \right ) } } \\]
+
+연속확률분포의 쿨백-라이블러 발산은 적분 값으로 주어진다. (이때 $p, q$는 각 확률분포의 확률밀도 함수이다.)
+
+\\[ KL\left( P\|\|Q \right) = \int^\infty_{-\infty} p\left( x \right) \log{ \frac{ p\left( x \right )}{ q\left( x \right ) } }dx \\]
+
+엔트로피와 쿨백라이블러 발산을 알아봤으니 이어서 다음 포스팅은 cross entropy 내용에 대해 알아보도록 하겠다.
\ No newline at end of file
diff --git a/_posts/2022-04-28-cross-entropy.markdown b/_posts/2022-04-28-cross-entropy.markdown
new file mode 100644
index 00000000000..523948d08e1
--- /dev/null
+++ b/_posts/2022-04-28-cross-entropy.markdown
@@ -0,0 +1,40 @@
+---
+title: "Cross Entropy(교차 엔트로피)"
+author: Kwon
+date: 2022-04-28T00:10:00+0900
+categories: [background, loss]
+tags: [entropy, kl-divergence, cross-entropy]
+math: true
+mermaid: false
+---
+
+### Related Post
+
+1. [Entropy](/posts/entropy/)
+2. [KL Divergence](/posts/KL-divergence/)
+3. **Cross Entropy**
+
+***
+## Cross Entropy
+
+교차 엔트로피의 의미는 이름에서 찾아볼 수 있다. 먼저 교차 엔트로피의 식을 한번 보자.
+
+\\[ H\left( P, Q \right) = -\sum^n_{i=1} p\left( x_i \right) \log{ q\left( x_i\right ) } \\]
+
+엔트로피 식에 $P$와 $Q$의 밀도함수들이 **교차**해서 들어가 있다. 그런 의미에서 교차 엔트로피라는 이름이 붙은 것이다.
+
+이 식의 의미는 [KL divergence 포스팅](/posts/KL-divergence/)에서 확인할 수 있듯이 확률분포 $P$를 근사하는 $Q$를 $P$ 대신 사용하여 샘플링했을 때의 엔트로피를 말한다.
+
+그런데 어떻게 이런 의미를 가지는 교차 엔트로피가 그 자체로 loss의 역할을 할 수 있는 걸까? 실제로 loss를 구하기 위해서는 원래 분포의 엔트로피와의 차이를 구해야 할 것이다. 이는 쿨백-라이블러 발산의 의미와 동일하다.
+쿨백-라이블러 발산의 식은 다음과 같았다.
+
+\\[ KL\left( P\|\|Q \right) = H\left( P, Q \right) - H\left( P \right) \\]
+
+분명 교차 엔트로피 말고도 원래 확률분포의 엔트로피인 $ H\left( P \right) $ 항이 존재한다. 하지만 우리가 loss를 사용하게 되는 실제 classification problem에 대해서 한번 생각해 보자.
+
+classification problem에서 우리는 한 data에 대해 정답이 주어져 있다고 가정한다. 이 말은 **이미 정해져 있는 정답에 속하는 것이 불확실하지 않다**는 말이기 때문에 $P = 1$이고 그에 따라 $ H\left( P \right) = 0$이다.
+그러므로 $ H\left( P \right) $ 항을 무시하고 다음과 같이 적을 수 있다.
+
+\\[ KL\left( P\|\|Q \right) = H\left( P, Q \right) =  -\sum^n_{i=1} p\left( x_i \right) \log{ q\left( x_i\right ) } \\]
+
+이런 이유 때문에 교차 엔트로피 자체가 loss로 기능할 수 있는 것이다.
\ No newline at end of file
diff --git a/_posts/2022-04-29-dlZeroToAll-PyTorch-4_1.markdown b/_posts/2022-04-29-dlZeroToAll-PyTorch-4_1.markdown
new file mode 100644
index 00000000000..c4fed6ec508
--- /dev/null
+++ b/_posts/2022-04-29-dlZeroToAll-PyTorch-4_1.markdown
@@ -0,0 +1,274 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab4_1: Multivariate Linear Regression"
+author: Kwon
+date: 2022-04-29T14:00:00+0900
+categories: [pytorch, study]
+tags: [multivariate-linear-regressoin]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 4_1: Multivariate Linear Regression 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## Theoretical Overview
+이전 포스팅까지의 regression은 하나의 변수를 통해 예측을 하는 것이었다. 하지만 직관적으로 생각해 보더라도 여러 변수를 가지고 더 많은 정보를 통해 예측하면 더 좋은 결과가 나올 것 같다.
+**Multivariate Linear Regression**은 이처럼 여러 변수를 input으로 사용하여 예측하는 것을 말한다.
+
+Hypothesis와 Cost는 앞에서 사용했던 것들을 사용하되 변수가 늘어난 것에 맞춰 수정해야 한다. 수정해서 나온 hypothesis와 cost는 다음과 같다.
+
+\\[ H(x_1, x_2, x_3) = x_1w_1 + x_2w_2 + x_3w_3 + b \\]
+\\[ cost(W, b) = \frac{1}{m} \sum^m_{i=1} \left( H(x^{(i)}) - y^{(i)} \right)^2 \\]
+
+변수의 수에 따라 hypothesis가 변한 것을 확인할 수 있다. 이때 각각의 변수에 대해 $W$가 따로 주어진다. 
+
+***
+## Import
+{% highlight python %}
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+{% endhighlight %}
+
+***
+## Data and Hypothesis
+### Data
+데이터는 다음과 같이 3개의 퀴즈 점수(x)와 최종 시험 점수(y)를 포함하는 셋을 사용할 것이다.
+
+| Quiz 1 (x1) | Quiz 2 (x2) | Quiz 3 (x3) | Final (y) |
+|:-----------:|:-----------:|:-----------:|:---------:|
+| 73 | 80 | 75 | 152 |
+| 93 | 88 | 93 | 185 |
+| 89 | 91 | 80 | 180 |
+| 96 | 98 | 100 | 196 |
+| 73 | 66 | 70 | 142 |
+{:.inner-borders}
+
+{% highlight python %}
+x1_train = torch.FloatTnsor([[73], [93], [89], [96], [73]])
+x2_train = torch.FloatTensor([[80], [88], [91], [98], [66]])
+x3_train = torch.FloatTensor([[75], [93], [90], [100], [70]])
+
+y_train = torch.FloatTensor([[152], [185], [180], [196], [142]])
+{% endhighlight %}
+<br>
+### Hypothesis Function
+위 데이터에 대해 hypothesis를 코드로 표현하면 다음과 같이 표현할 수 있다.
+
+{% highlight python %}
+hypothesis = x1_train * w1 + x2_train * w2 + x3_train * w3 + b
+{% endhighlight %}
+
+하지만 input 변수의 개수가 100개, 1000개 일 때도 위와 같이 hypothesis와 데이터셋을 정의할 수는 없는 노릇이다. 이걸 간단하게 만들기 위해 $x_1w_1 + x_2w_2 + x_3w_3$를 행렬곱으로 바꿔 생각해 보자.
+
+각 변수와 가중치의 곱은 아래와 같은 행렬 곱과 같다.
+
+\\[
+\begin{pmatrix}
+x_1 & x_2 & x_3
+\end{pmatrix}
+\cdot
+\begin{pmatrix}
+w_1 \\\\\\
+w_2 \\\\\\
+w_3 \\\\\\
+\end{pmatrix}
+=
+\begin{pmatrix}
+x_1w_1 + x_2w_2 + x_3w_3
+\end{pmatrix}
+\\]
+
+그러므로 [lab1](/posts/dlZeroToAll-PyTorch-1/)에서 나왔던 `matmul()`을 사용하여 변수와 가중치의 곱을 간단하게 구할 수 있다.
+
+{% highlight python %}
+x_train = torch.FloatTensor([[73, 80, 75],
+                             [93, 88, 93],
+                             [89, 91, 90],
+                             [96, 98, 100],
+                             [73, 66, 70]])
+y_train = torch.FloatTensor([[152], [185], [180], [196], [142]])
+
+hypothesis = x_train.matmul(W) # W의 차원은 [변수의 개수, 1]로 맞춰 줄 것
+{% endhighlight %}
+
+이때 주의할 것은 행렬곱 연산이 가능하도록 `W`의 차원을 변수에 개수에 따라 맞춰줘야 한다는 것이다.
+
+
+***
+## Train
+Multivariate Linear Regression의 hypothesis까지 모두 알아봤으니 학습하는 전체적인 코드를 작성해 보자.
+
+[lab3](/posts/dlZeroToAll-PyTorch-3/)의 **Train with `optim`**의 코드와 크게 다르지 않지만
+`W = torch.zeros((3, 1), requires_grad=True)`에서 가중치의 차원을 변수의 개수에 따라 맞춰준 것만 차이가 난다.
+
+{% highlight python %}
+# 모델 초기화
+W = torch.zeros((3, 1), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+# optimizer 설정
+optimizer = optim.SGD([W, b], lr=1e-5)
+
+nb_epochs = 20
+for epoch in range(nb_epochs + 1):
+    
+    # H(x) 계산
+    hypothesis = x_train.matmul(W) + b # or .mm or @
+
+    # cost 계산
+    cost = torch.mean((hypothesis - y_train) ** 2)
+
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    # 로그 출력
+    print('Epoch {:4d}/{} hypothesis: {} Cost: {:.6f}'.format(
+        epoch, nb_epochs, hypothesis.squeeze().detach(), cost.item()
+    ))
+
+'''output
+Epoch    0/20 hypothesis: tensor([0., 0., 0., 0., 0.]) Cost: 29661.800781
+Epoch    1/20 hypothesis: tensor([67.2578, 80.8397, 79.6523, 86.7394, 61.6605]) Cost: 9298.520508
+Epoch    2/20 hypothesis: tensor([104.9128, 126.0990, 124.2466, 135.3015,  96.1821]) Cost: 2915.712402
+Epoch    3/20 hypothesis: tensor([125.9942, 151.4381, 149.2133, 162.4896, 115.5097]) Cost: 915.040649
+Epoch    4/20 hypothesis: tensor([137.7967, 165.6247, 163.1911, 177.7112, 126.3307]) Cost: 287.936157
+Epoch    5/20 hypothesis: tensor([144.4044, 173.5674, 171.0168, 186.2332, 132.3891]) Cost: 91.371010
+Epoch    6/20 hypothesis: tensor([148.1035, 178.0143, 175.3980, 191.0042, 135.7812]) Cost: 29.758249
+Epoch    7/20 hypothesis: tensor([150.1744, 180.5042, 177.8509, 193.6753, 137.6805]) Cost: 10.445281
+Epoch    8/20 hypothesis: tensor([151.3336, 181.8983, 179.2240, 195.1707, 138.7440]) Cost: 4.391237
+Epoch    9/20 hypothesis: tensor([151.9824, 182.6789, 179.9928, 196.0079, 139.3396]) Cost: 2.493121
+Epoch   10/20 hypothesis: tensor([152.3454, 183.1161, 180.4231, 196.4765, 139.6732]) Cost: 1.897688
+Epoch   11/20 hypothesis: tensor([152.5485, 183.3609, 180.6640, 196.7389, 139.8602]) Cost: 1.710555
+Epoch   12/20 hypothesis: tensor([152.6620, 183.4982, 180.7988, 196.8857, 139.9651]) Cost: 1.651412
+Epoch   13/20 hypothesis: tensor([152.7253, 183.5752, 180.8742, 196.9678, 140.0240]) Cost: 1.632369
+Epoch   14/20 hypothesis: tensor([152.7606, 183.6184, 180.9164, 197.0138, 140.0571]) Cost: 1.625924
+Epoch   15/20 hypothesis: tensor([152.7802, 183.6427, 180.9399, 197.0395, 140.0759]) Cost: 1.623420
+Epoch   16/20 hypothesis: tensor([152.7909, 183.6565, 180.9530, 197.0538, 140.0865]) Cost: 1.622141
+Epoch   17/20 hypothesis: tensor([152.7968, 183.6643, 180.9603, 197.0618, 140.0927]) Cost: 1.621262
+Epoch   18/20 hypothesis: tensor([152.7999, 183.6688, 180.9644, 197.0661, 140.0963]) Cost: 1.620501
+Epoch   19/20 hypothesis: tensor([152.8014, 183.6715, 180.9665, 197.0686, 140.0985]) Cost: 1.619764
+Epoch   20/20 hypothesis: tensor([152.8020, 183.6731, 180.9677, 197.0699, 140.0999]) Cost: 1.619046
+'''
+{% endhighlight %}
+
+hypothesis의 출력값과 cost를 보면 정답에 점점 근접하는 것을 확인할 수 있다. 이 경우에도 lab3에서 언급한 것과 같이 learning rate에 따라 cost의 극소점을 지나쳐 발산할 수도 있다.
+
+***
+## High-level Implementation with `nn.Module`
+PyTorch의 `nn.Module`을 상속하여 모델을 생성하면 hypothesis 정의, cost 계산 등의 학습에 필요한 여러 요소들을 편하게 만들고 사용할 수 있다.
+
+### Model
+`nn.Module`을 이용하여 모델을 생설할 때는 다음과 같은 형식을 따라야 한다.
+
+1. `nn.Module`를 상속해야 한다.
+2. `__init__`과 `forward()`를 override 해야한다.
+   * `__init__`: 모델에 사용될 module을 정의. `super().__init__()`으로 `nn.Module`의 속성으로 초기화
+   * `forward()`: **Hypothesis**가 들어갈 곳. (Hypothesis에 input을 넣어 predict하는 것을 forward 연산이라고 함)
+
+{% highlight python %}
+class LinearRegressionModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = nn.Linear(1, 1)
+
+    def forward(self, x):
+        return self.linear(x)
+{% endhighlight %}
+
+이렇게 모델을 정의하면 우리가 직접 W, b를 명시하여 hypothesis를 정의해 주지 않아도 된다. gradient 계산인 `backward()`는 PyTorch가 알아서 해주기 때문에 신경쓰지 않아도 된다.
+
+{% highlight python %}
+# 기존의 모델 초기화
+W = torch.zeros((3, 1), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+
+hypothesis = x_train.matmul(W) + b
+
+# nn.Module을 활용한 모델 초기화
+class MultivariateLinearRegressionModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = nn.Linear(3, 1)
+
+    def forward(self, x):
+        return self.linear(x)
+{% endhighlight %}
+
+Multivariate Linear Regression Model을 생성할 때도 `nn.Linear()`의 차원을 조절해 주는 것으로 간단히 모델을 생성할 수 있다.
+이렇게 모델의 수정이 자유로운 것은 `nn.Module`의 확장성을 잘 보여주는 부분이라고 생각한다.
+
+<br>
+
+### Cost (`nn.functional`)
+cost도 `torch.nn.functional`를 이용해서 간단히 정의할 수 있다.
+
+{% highlight python %}
+cost = F.mse_loss(prediction, y_train)
+{% endhighlight %}
+
+계속 사용하던 MSE를 위와 같이 정의하면 추후에 다른 loss를 사용하려고 할 때 loss 함수만 변경해 주면 되기 때문에 훨씬 편리하다.
+
+<br>
+
+### Training with `nn.Module`
+앞서 새롭게 정의했던 모델과 cost를 이용하여 전체 학습 코드를 작성하면 다음과 같다.
+나머지 부분은 크게 차이가 없고, hypothesis와 cost를 정의하는 부분이 더 간결해진 모습을 볼 수 있다.
+
+{% highlight python %}
+# 데이터
+x_train = torch.FloatTensor([[73, 80, 75],
+                             [93, 88, 93],
+                             [89, 91, 90],
+                             [96, 98, 100],
+                             [73, 66, 70]])
+y_train = torch.FloatTensor([[152], [185], [180], [196], [142]])
+# 모델 초기화
+model = MultivariateLinearRegressionModel()
+# optimizer 설정
+optimizer = optim.SGD(model.parameters(), lr=1e-5)
+
+nb_epochs = 20
+for epoch in range(nb_epochs+1):
+    
+    # H(x) 계산
+    prediction = model(x_train)
+    
+    # cost 계산
+    cost = F.mse_loss(prediction, y_train)
+    
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+    
+    # 로그 출력
+    print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+        epoch, nb_epochs, cost.item()
+    ))
+
+'''output
+Epoch    0/20 Cost: 31667.599609
+Epoch    1/20 Cost: 9926.266602
+Epoch    2/20 Cost: 3111.514160
+Epoch    3/20 Cost: 975.451172
+Epoch    4/20 Cost: 305.908539
+Epoch    5/20 Cost: 96.042679
+Epoch    6/20 Cost: 30.260782
+Epoch    7/20 Cost: 9.641659
+Epoch    8/20 Cost: 3.178671
+Epoch    9/20 Cost: 1.152871
+Epoch   10/20 Cost: 0.517862
+Epoch   11/20 Cost: 0.318802
+Epoch   12/20 Cost: 0.256388
+Epoch   13/20 Cost: 0.236816
+Epoch   14/20 Cost: 0.230657
+Epoch   15/20 Cost: 0.228718
+Epoch   16/20 Cost: 0.228094
+Epoch   17/20 Cost: 0.227880
+Epoch   18/20 Cost: 0.227803
+Epoch   19/20 Cost: 0.227759
+Epoch   20/20 Cost: 0.227729
+'''
+{% endhighlight %}
diff --git a/_posts/2022-04-30-dlZeroToAll-PyTorch-4_2.markdown b/_posts/2022-04-30-dlZeroToAll-PyTorch-4_2.markdown
new file mode 100644
index 00000000000..f38f9e97eb3
--- /dev/null
+++ b/_posts/2022-04-30-dlZeroToAll-PyTorch-4_2.markdown
@@ -0,0 +1,188 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab4_2: Loading Data"
+author: Kwon
+date: 2022-04-30T00:00:00 +0900
+categories: [pytorch, study]
+tags: [multivariate-linear-regressoin]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 4_2: Loading Data 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## Data in the Real World
+[lab4_1](/posts/dlZeroToAll-PyTorch-4_1/)에서 다루었던 Multivariate Linear Regression에서는 학습 데이터로 3개의 차원을 가진 5개의 샘플을 사용했었다.
+하지만 실제 우리가 다루려고 하는 데이터는 그 크기가 그리 만만하지 않다. 본 강의에서 예를 들었던 **ImageNet**의 경우 1400만개 이상을 이미지 데이터 셋을 포함하고 있으며 그 용량이 120GB 이상이다.
+이 데이터를 한번에 학습을 진행한다는 것은 하드웨어 상의 용량 문제도 있겠지만, 하드웨어적인 문제가 해결된다 하더라도 느리고 Gradient Descent 시에 cost 연산에 대한 computing power 부담이 너무 크다.
+
+이런 문제점을 해결하기 위해 등장한 것이 Minibatch이다. 데이터가 너무 크니까 **'데이터의 일부로 학습하면 어떨까?'**라는 생각에 나온 개념이다.
+
+***
+## Minibatch Gradient Descent
+앞에서 잠간 언급한 것처럼, 대용량 데이터를 균일하게 나눠 gradient dscent를 하는 것을 Minibatch Gradient Descent라고 한다.
+이렇게 학습을 하는 경우 업데이트가 빠르고 하드웨어적인 부담도 덜 수 있다.
+하지만 어디까지나 전체가 아닌 일부 데이터를 써서 학습하는 것이기 때문에 잘못된 방향으로 학습이 될 수도 있고,
+결과적으로 어느정도 수렴하더라도 그 과정이 아래 그림과 같이 좀 거칠게 Gradient descent 될 수도 있다. (아래 그림은 이해를 위한 임의의 그래프이며, 실제 loss의 그래프가 아닙니다.)
+
+![Minibatch Gradient Decsent](/posting_imgs/lab4_2-1.png)
+
+![Gradient Decsent](/posting_imgs/lab4_2-2.png)
+
+***
+## Dataset
+### PyTorch Dataset
+`torch.utils.data.Dataset`을 상속하여 사용자 정의 데이터 셋을 만들어 사용할 수 있다. 이 방식으로 데이터 셋을 정의할 경우 다음과 같은 형식을 따라야 한다.
+1. `torch.utils.data.Dataset`을 상속해야 한다.
+2. `__init__`, `__len__` 그리고 `__getitem__`을 override 해야 한다.
+   * `__init__`   : 데이터 셋을 만들 때(`Dataset`객체가 생성될 때)만 실행됨. 실제도 데이터를 정의하는 곳.
+   * `__len__`    : 데이터 셋의 총 데이터 수를 반환함.
+   * `__getitem__`: 주어진 인덱스(`idx`)에 따라 그 인덱스에 맞는 x, y 데이터를 반환함.
+
+lab4_1에서 사용했던 데이터로 데이터 셋을 만드는 과정은 다음과 같다.
+
+```python
+from torch.utils.data import Dataset
+
+class CustomDataset(Dataset):
+    def __init__(self):
+        self.x_data = [[73, 80, 75],
+                       [93, 88, 93], 
+                       [89, 91, 90],
+                       [96, 98, 100],
+                       [73, 66, 70]]
+        self.y_data = [[152], [185], [180], [196], [142]]
+        
+    def __len__(self):
+        return len(self.x_data)
+    
+    def __getitem__(self, idx):
+        return torch.FloatTensor(self.x_data[idx]), torch.FloatTensor(self.y_data[idx])
+    
+dataset = CustomDataset()
+```
+
+원하는 데이터를 넣어 데이터 셋 class를 만든 후 인스턴스를 생성해 준다.
+
+### PyTorch DataLoader
+`torch.utils.data.DataLoader`를 사용하면 `Dataset` 객체의 데이터에 대해 minibatch를 자동으로 제공하여 batch에 대한 반복을 쉽게 할 수 있도록 해준다.
+
+```python
+from torch.utils.data import DataLoader
+
+dataloader = DataLoader(
+    dataset,
+    batch_size=2,
+    shuffle=True
+)
+```
+
+위와 같이 설정하면 각 minibatch들의 크기를 2로 나누어 제공한다. `batch_size`는 통상적으로 2의 제곱수(16, 32, 64, 128, 256...)로 설정하는데 이는 GPU memory가 2의 거듭제곱이기 때문이다.
+
+경우에 따라 66개의 batch나 120개의 batch나 (둘 다 $2^6$과 $2^7$ 사이의 범위이다. 예를 들자면 그렇다는 것) 필요한 시간이 동일한 경우가 발생할 수 있다. 그러므로 최대의 효율을 위해 GPU memory에 크기를 맞춰주는 것이다. 또 하나 일반적으로 알려진 것으로는 batch size가 작을수록 시간은 오래 걸리고, 효과가 좋다는 것이다.
+
+shuffle 옵션은 데이터를 epoch마다 섞어서 모델이 데이터의 순서를 외우는 것을 방지할 수 있도록 해 준다. 대부분의 경우 데이터의 순서를 외우지 못하도록 학습하는 것이 좋으므로 Ture로 해 놓는 것이 좋다.
+
+***
+## Full Code with `Dataset` and `DataLoader`
+`Dataset` 과 `DataLoader`를 이용하여 학습하는 코드를 작성해보자.
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+class MultivariateLinearRegressionModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = nn.Linear(3, 1)
+    
+    def forward(self, x):
+        return self.model(x)
+
+# 모델 초기화
+model = MultivariateLinearRegressionModel()
+# optimizer 설정
+optimizer = optim.SGD(model.parameters(), lr=1e-5)
+```
+
+모델, optimizer는 lab4_1과 동일하게 정의해주고
+
+```python
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+
+class CustomDataset(Dataset):
+    def __init__(self):
+        self.x_data = [[73, 80, 75],
+                       [93, 88, 93], 
+                       [89, 91, 90],
+                       [96, 98, 100],
+                       [73, 66, 70]]
+        self.y_data = [[152], [185], [180], [196], [142]]
+        
+    def __len__(self):
+        return len(self.x_data)
+    
+    def __getitem__(self, idx):
+        return torch.FloatTensor(self.x_data[idx]), torch.FloatTensor(self.y_data[idx])
+    
+dataset = CustomDataset()
+
+dataloader = DataLoader(
+    dataset,
+    batch_size=2,
+    shuffle=True
+)
+```
+
+데이터 셋은 오늘 포스팅에 나온 방법으로 정의를 해준다.
+
+이들을 가지고 학습하는 코드는 이렇게 작성할 수 있다.
+
+```python
+epochs = 20
+for epoch in range(epochs + 1):
+    for batch_idx, smaples in enumerate(dataloader):
+        x_train, y_train = smaples
+        
+        prediction = model(x_train)
+        
+        cost = F.mse_loss(prediction, y_train)
+        
+        optimizer.zero_grad()
+        cost.backward()
+        optimizer.step()
+        
+        # 5 epoch 마다 로그 출력
+        if epoch%5 == 0:
+            print('Epoch {:4d}/{} Batch {}/{} Cost {:6f}'.format(
+                epoch, epochs, batch_idx, len(dataloader), cost.item()
+            ))
+
+'''output
+Epoch    0/20 Batch 0/3 Cost 390.795288
+Epoch    0/20 Batch 1/3 Cost 55.004257
+Epoch    0/20 Batch 2/3 Cost 18.470478
+Epoch    5/20 Batch 0/3 Cost 8.500160
+Epoch    5/20 Batch 1/3 Cost 3.519112
+Epoch    5/20 Batch 2/3 Cost 2.370358
+Epoch   10/20 Batch 0/3 Cost 2.786815
+Epoch   10/20 Batch 1/3 Cost 4.166077
+Epoch   10/20 Batch 2/3 Cost 5.060166
+Epoch   15/20 Batch 0/3 Cost 4.609153
+Epoch   15/20 Batch 1/3 Cost 6.680350
+Epoch   15/20 Batch 2/3 Cost 4.476605
+Epoch   20/20 Batch 0/3 Cost 4.082047
+Epoch   20/20 Batch 1/3 Cost 2.758399
+Epoch   20/20 Batch 2/3 Cost 4.820268
+'''
+```
+
+한 epoch 안에서 minibatch로 3번 학습하는 것을 확인할 수 있다. 다만 앞서 batch size가 작을수록 오래걸리고 효과는 좋다고 했는데 이번의 경우에는 성능이 그렇게 좋아 보이지 않는다(lab4_1에서의 최종 cost는 0.227729).
+
+그 이유는 batch size가 너무 작기 때문이다. 우리가 minibatch를 사용하여 학습을 할 수 있는 이유는 minibatch가 전체 데이터 셋을 대표할 수 있다고 가정하기 때문이다. 하지만 이번 상황을 보면 batch size가 2 밖에 되지 않는다.
+이정도 크기로는 아무리 생각해도 전체 데이터의 분포를 대표하기에는 무리가 있어 보인다. 이런 이유 때문에 성능이 떨어진 것이라고 할 수 있다.
+
+그러므로 batch size를 설정할 때에는 충분히 전체 분포를 반영할 수 있도록 설정하는 주의를 기울여야 한다.
diff --git a/_posts/2022-04-30-dlZeroToAll-PyTorch-5.markdown b/_posts/2022-04-30-dlZeroToAll-PyTorch-5.markdown
new file mode 100644
index 00000000000..eda3dcfe325
--- /dev/null
+++ b/_posts/2022-04-30-dlZeroToAll-PyTorch-5.markdown
@@ -0,0 +1,451 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab5: Logistic Classification"
+author: Kwon
+date: 2022-04-30T00:00:00 +0900
+categories: [pytorch, study]
+tags: [logistic-classification, binary-cross-entropy]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 5: Logistic Classification 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## Logistic Regression(Binary Classification)
+Hypothesis로 sigmoid(logistic) 함수를 사용하는 회귀 방법이다. 흔히 Binary classification ploblem에 많이 사용하는데, 이 경우 왜 선형 회귀 대신 로지스틱 회귀를 사용하는지에 대해 먼저 알아보자
+
+### Hypothesis
+공부 시간에 따른 시험 합격 여부 데이터 셋을 생각해 보자($y=1$: 합격, $y=0$: 불합격).
+
+먼저 이 데이터 셋의 예측 문제를 선형 회귀를 통해 접근해 볼 것이다. 기존의 선형 회귀식의 hypothesis는 $H(x_1, x_2, x_3) = xw + b$로 주어졌었다.
+학습 초기에는 2.5시간(초록색 점선)을 기준으로 합격이 결정되었다고 가정해 보자
+
+![](/posting_imgs/lab5-1.png)
+
+위와 같이 회귀 함수를 학습하면 x(공부 시간)가 주어졌을 때 y가 0.5를 넘었는가 여부에 따라 분류가 가능할 것이다(0.5를 넘으면 합격으로 처리하면 된다).
+
+하지만 이 회귀식의 범위를 넘어서는 값 즉, 학습된 hypothesis에 넣었을 때 prediction이 $[0, 1]$를 벗어나는 값이 있다면 그에 맞춰 회귀선을 다시 학습해야 한다.
+
+![](/posting_imgs/lab5-2.png)
+
+위처럼 9시간(빨간 O) 공부한 사람에 맞춰 학습을 다시 하면 2.5시간에서 5시간 사이의 범위에 있는 사람들은 모델이 불합격한 것으로 판단하게 된다.
+
+이런 상황과 같이 적절한 분류를 하기 힘든 경우가 실제 데이터에서는 무수히 많이 존재할 수 있고, 학습이 끝난 이후 예측을 할 때 prediction의 범위가 $[0, 1]$을 벗어날 수 있다는 문제도 있다.
+이러한 이유들로 선형 회귀만으로 접근하는 것은 분류 문제에는 적합하지 않다고 할 수 있다.
+
+이번에는 로지스틱 회귀로 이 문제를 접근해 보자. 먼저 시그모이드 함수(로지스틱 함수)는 다음과 같이 정의된다.
+
+\\[ s(z) = \frac{1}{1+e^{-z}} \\]
+
+이를 그래프로 그려보면 아래와 같은 형태를 띈다.
+
+![](/posting_imgs/lab5-3.png){: height="60%"}
+
+그림으로도 확인할 수 있는 것처럼 시그모이드 함수는 항상 0과 1 사이에 값이 존재하여 앞서 언급한 선형 회귀의 문제점을 해결할 수 있다.
+선형 회귀식을 시그모이드 함수의 인풋으로 넣으면 선형 회귀식에서 어떤 값이 나오든 0과 1사이의 범위를 넘어 생기는 문제가 일어나지 않을 것이다.
+
+그러므로 로지스틱 회귀의 hypothesis는 로지스틱 함수에 선형 회귀식을 넣는 것으로 정의된다.
+
+\\[ H(X) = \frac{1}{1+e^{-W^T X}} \\]
+
+이 hypothesis를 따른다면 아무리 크거나 작은 값이 주어지더라도 0과 1사이를 벗어나지 않기 때문에 기존에 합격이라고 분류 된 값이 갑자기 불합격이 될 가능성이 매우 줄어든다.
+
+이처럼 binary classification에 적합한 값으로 만들어 주는 특성 때문에 로지스틱 회귀 뿐만 아니라, neural network를 이용한 binary classification에서 output 직전의 마지막 레이어로도 사용된다. 이 때문에 activation function(활성화 함수)중 하나이기도 하다.
+<br><br>
+
+### Cost(Binary Cross Entropy)
+Hpothesis도 정의했으니 cost를 정의할 차례이다. 시그모이드 함수의 경우 선형 회귀에서 썼던 MSE를 사용하면 local minimun이 있을 수 있기 때문에 제대로 된 학습이 되지 않을 수 있다.
+
+말로 하기보다 그래프로 한번 확인해 보자.
+```python
+import matplotlib.pyplot as plt
+import torch
+import numpy as np
+import os
+os.environ['KMP_DUPLICATE_LIB_OK']='True'
+
+x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]
+y_data = [[0], [0], [0], [1], [1], [1]]
+W_l = np.linspace(-3, 3, 1000)
+cost_l = []
+for W in W_l:
+    hypothesis = 1 / (1 + torch.exp(-(W * x_train)))
+    cost = torch.mean((hypothesis - y_train) ** 2)
+
+    cost_l.append(cost.item())
+
+plt.plot(W_l, cost_l)
+plt.xlabel('$W$')
+plt.ylabel('Cost')
+plt.show()
+```
+
+![](/posting_imgs/lab5-4.png)
+
+우리가 생각하기에 `W`가 0 근처의 값으로 수렴하는 것이 맞아 보인다. 하지만 gradient descent를 시작하는 점이 -1 부근, 혹은 더 작은 값이라면 우리가 원하는 방향과 반대로 극소점을 찾아갈 것이다. 그 방향에도 극소점이 있을 수 있겠지만 그건 우리가 원하는 global minimum이 아니다.
+
+위 그래프는 조금 애매하다고 느낄 수 있겠지만 실제로 cost에 global minimum이 아닌 여러 극소점이 있다는 것은 확실히 학습이 잘 되지 않을 것이라는 건 알 수 있다.
+
+그래서 cost로 다음과 같은 함수를 사용한다.
+
+\\[  cost(W) = -\frac{1}{m} \sum y \log\left(H(x)\right) + (1-y) \left( \log(1-H(x) \right) \\]
+
+log를 사용하여 지수함수를 다루기 좋은 형태로 만들어 주고, 정답에 따라 적절한 cost를 사용할 수 있도록 만들었는데 그 cost의 형태는 다음과 같다.
+
+![](/posting_imgs/lab5-5.png){: height="50%" aligncenter}
+
+답이 1인 경우(초록색) 0에 가까울 때 cost가 올라가고 1일 때 0이도록, 답이 0인 경우 그 반대로 작동하게 cost를 정의하였다.
+덕분에 시그모이드를 이용해서 학습하기에 적절한 cost의 형태가 되었다.
+
+이를 통한 gradient descent는 전과 동일한 형태로 진행한다.
+
+\\[ W := W - \alpha \frac{\partial}{\partial W} cost(W) \\]
+
+***
+## Import
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+# seed 고정
+torch.manual_seed(1)
+```
+
+***
+## Training data
+```python
+x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]
+y_data = [[0], [0], [0], [1], [1], [1]]
+
+x_train = torch.FloatTensor(x_data)
+y_train = torch.FloatTensor(y_data)
+
+print(x_train.shape)
+print(y_train.shape)
+
+'''output
+torch.Size([6, 2])
+torch.Size([6, 1])
+'''
+```
+
+***
+## Computing Hypothesis and Cost Function
+일단은 수식 그대로 코드를 작성해서 사용해보자.
+
+### Hypothesis
+\\[ H(X) = \frac{1}{1+e^{-W^T X}} \\]
+
+```python
+W = torch.zeros((2, 1), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+
+hothesis = 1 / (1 + torch.exp(-(x_train.matmul(W) + b)))
+
+print(hypothesis)
+print(hypothesis.shape)
+
+'''output
+tensor([[0.5000],
+        [0.5000],
+        [0.5000],
+        [0.5000],
+        [0.5000],
+        [0.5000]], grad_fn=<MulBackward>)
+torch.Size([6, 1])
+'''
+```
+`torch.exp(x)`로 $e^x$연산을 할 수 있다.
+W와 b가 모두 0이기 때문에 0.5가 output으로 나온 것을 확인할 수 있다.
+
+### Cost
+\\[  cost(W) = -\frac{1}{m} \sum y \log\left(H(x)\right) + (1-y) \left( \log(1-H(x) \right) \\]
+
+```python
+losses = -(y_train * torch.log(hypothesis) + (1 - y_train) * torch.log(1 - hypothesis))
+print(losses)
+
+'''output
+tensor([[0.6931],
+        [0.6931],
+        [0.6931],
+        [0.6931],
+        [0.6931],
+        [0.6931]], grad_fn=<NegBackward>)
+'''
+```
+
+$log$ 연산도 마찬가지로 `torch.log()`를 통해 할 수 있다.
+loss도 잘 출력된다.
+
+### Full code
+```python
+# 모델 초기화
+W = torch.zeros((2, 1), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+# optimizer 설정
+optimizer = optim.SGD([W, b], lr=1)
+
+nb_epochs = 1000
+for epoch in range(nb_epochs + 1):
+
+    # Cost 계산
+    hypothesis = torch.sigmoid(x_train.matmul(W) + b) # or .mm or @
+    cost = -(y_train * torch.log(hypothesis) + 
+             (1 - y_train) * torch.log(1 - hypothesis)).mean()
+
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    # 100번마다 로그 출력
+    if epoch % 100 == 0:
+        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+            epoch, nb_epochs, cost.item()
+        ))
+
+'''output
+Epoch    0/1000 Cost: 0.693147
+Epoch  100/1000 Cost: 0.134722
+Epoch  200/1000 Cost: 0.080643
+Epoch  300/1000 Cost: 0.057900
+Epoch  400/1000 Cost: 0.045300
+Epoch  500/1000 Cost: 0.037261
+Epoch  600/1000 Cost: 0.031673
+Epoch  700/1000 Cost: 0.027556
+Epoch  800/1000 Cost: 0.024394
+Epoch  900/1000 Cost: 0.021888
+Epoch 1000/1000 Cost: 0.019852
+'''
+```
+
+hypothesis와 cost가 달리진 것 외에는 이전의 lab들에서 학습하는 코드와 달라진 것이 없다.
+
+## Computing Hypothesis and Cost Function with `torch`
+시그모이드 함수와 binary cross entropy는 PyTorch에서 기본적으로 제공하기 때문에 굳이 위처럼 구현하지 않고 사용할 수 있다
+
+```python
+hypothesis = torch.sigmoid(x_train.matmul(W) + b)
+
+print(hypothesis)
+print(hypothesis.shape)
+ptint(F.binary_cross_entropy(hypothesis, y_train))
+
+'''output
+tensor([[0.5000],
+        [0.5000],
+        [0.5000],
+        [0.5000],
+        [0.5000],
+        [0.5000]], grad_fn=<SigmoidBackward>)
+torch.Size([6, 1])
+tensor(0.6931, grad_fn=<BinaryCrossEntropyBackward>)
+'''
+```
+
+앞서 수식으로 구현했던 것과 동일한 결과가 나온다.
+
+### Full Code
+```python
+# 모델 초기화
+W = torch.zeros((2, 1), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+# optimizer 설정
+optimizer = optim.SGD([W, b], lr=1)
+
+nb_epochs = 1000
+for epoch in range(nb_epochs + 1):
+
+    # Cost 계산
+    hypothesis = torch.sigmoid(x_train.matmul(W) + b) # or .mm or @
+    cost = F.binary_cross_entropy(hypothesis, y_train)
+
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    # 100번마다 로그 출력
+    if epoch % 100 == 0:
+        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+            epoch, nb_epochs, cost.item()
+        ))
+'''output
+Epoch    0/1000 Cost: 0.693147
+Epoch  100/1000 Cost: 0.134722
+Epoch  200/1000 Cost: 0.080643
+Epoch  300/1000 Cost: 0.057900
+Epoch  400/1000 Cost: 0.045300
+Epoch  500/1000 Cost: 0.037261
+Epoch  600/1000 Cost: 0.031672
+Epoch  700/1000 Cost: 0.027556
+Epoch  800/1000 Cost: 0.024394
+Epoch  900/1000 Cost: 0.021888
+Epoch 1000/1000 Cost: 0.019852
+'''
+```
+
+마잔가지로 hypothesis와 cost만 달라지고 기본적인 틀은 같다. 학습도 잘 되는 모습이다.
+
+***
+## Evaluation
+우리가 만든 모델이 얼마나 정확한지 확인해보자
+
+실제 우리가 만든 모델은 시그모이드 함수의 결과값이기 때문에 다음과 같이 소수의 형태로 나타난다.
+
+```python
+hypothesis = torch.sigmoid(x_train.matmul(W) + b)
+print(hypothesis[:5])
+
+'''output
+tensor([[0.4103],
+        [0.9242],
+        [0.2300],
+        [0.9411],
+        [0.1772]], grad_fn=<SliceBackward>)
+'''
+```
+
+실제로는 0또는 1의 값을 가지기 때문에 어떤 기준을 통해 결과값을 맞춰 줄 필요가 있어 보인다. 여기서는 0.5를 기준으로 0과 1을 나눈다고 생각하고 진행했다.
+
+```python
+prediction = hypothesis >= torch.FloatTensor([0.5])
+print(prediction[:5])
+
+'''output
+tensor([[0],
+        [1],
+        [0],
+        [1],
+        [0]], dtype=torch.uint8)
+'''
+```
+
+이렇게 하면 0.5 이상의 값은 1로, 미만의 값는 0으로 맵핑하여 `ByteTensor`의 형태로 돌려준다.
+
+실제 값과 비교해 보면 잘 예측한 것을 확인할 수 있다.
+
+```python
+print(prediction[:5])
+print(y_train[:5])
+
+correct_prediction = prediction.float() == y_train
+print(correct_prediction[:5])
+
+'''output
+tensor([[0],
+        [1],
+        [0],
+        [1],
+        [0]], dtype=torch.uint8)
+tensor([[0.],
+        [1.],
+        [0.],
+        [1.],
+        [0.]])
+
+tensor([[1],
+        [1],
+        [1],
+        [1],
+        [1]], dtype=torch.uint8)
+'''
+```
+
+모델이 예측한 값이 실제와 같았을 때 1을 반환하도록 했을 때 모두 1이 나왔으므로 주어진 간단한 데이터 셋에 한해서는 잘 학습이 되었다고 할 수 있다.
+
+***
+## Higher Implementation with Class
+Bynary Classification 문제에서 Sigmoid Reggression을 사용하려고 할 때 [lab4_1](/posts/dlZeroToAll-PyTorch-4_1/)에서 나왔건 것처럼 `Module`을 사용하여 calss를 만들어 진행할 수 있다.
+
+이번에 사용한 데이터 셋은 모두를 위한 딥러닝 코드와 함께 제공되는 당뇨병 데이터셋이며 8개 차원의 인폿과 당뇨병 여부에 따른 0, 1의 값으로 데이터가 구성되어 있다.
+
+### Loading Real Data
+```python
+import numpy as np
+
+xy = np.loadtxt('data-03-diabetes.csv', delimiter=',', dtype=np.float32)
+x_data = xy[:, 0:-1]
+y_data = xy[:, [-1]]
+x_train = torch.FloatTensor(x_data)
+y_train = torch.FloatTensor(y_data)
+
+print(x_train[0:5])
+print(y_train[0:5])
+
+'''output
+tensor([[-0.2941,  0.4874,  0.1803, -0.2929,  0.0000,  0.0015, -0.5312, -0.0333],
+        [-0.8824, -0.1457,  0.0820, -0.4141,  0.0000, -0.2072, -0.7669, -0.6667],
+        [-0.0588,  0.8392,  0.0492,  0.0000,  0.0000, -0.3055, -0.4927, -0.6333],
+        [-0.8824, -0.1055,  0.0820, -0.5354, -0.7778, -0.1624, -0.9240,  0.0000],
+        [ 0.0000,  0.3769, -0.3443, -0.2929, -0.6028,  0.2846,  0.8873, -0.6000]])
+tensor([[0.],
+        [1.],
+        [0.],
+        [1.],
+        [0.]])
+'''
+```
+
+### Train with Class
+차원에 맞춰 class를 정의해 준다. 이때 바로 시그모이드 함수에 넣는 것이 아니라 linear function으로 만들어 준 후에 적용해야 우리가 원하는 hypothesis가 만들어진다.
+
+```python
+class BinaryClassifier(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = nn.Linear(8, 1)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        return self.sigmoid(self.linear(x))
+```
+
+```python
+model = BinaryClassifier()
+
+# optimizer 설정
+optimizer = optim.SGD(model.parameters(), lr=1)
+
+nb_epochs = 100
+for epoch in range(nb_epochs + 1):
+
+    # H(x) 계산
+    hypothesis = model(x_train)
+
+    # cost 계산
+    cost = F.binary_cross_entropy(hypothesis, y_train)
+
+    # cost로 H(x) 개선
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+    
+    # 20번마다 로그 출력
+    if epoch % 10 == 0:
+        prediction = hypothesis >= torch.FloatTensor([0.5])
+        correct_prediction = prediction.float() == y_train
+        accuracy = correct_prediction.sum().item() / len(correct_prediction)
+        print('Epoch {:4d}/{} Cost: {:.6f} Accuracy {:2.2f}%'.format(
+            epoch, nb_epochs, cost.item(), accuracy * 100,
+        ))
+
+'''output
+Epoch    0/100 Cost: 0.704829 Accuracy 45.72%
+Epoch   10/100 Cost: 0.572391 Accuracy 67.59%
+Epoch   20/100 Cost: 0.539563 Accuracy 73.25%
+Epoch   30/100 Cost: 0.520042 Accuracy 75.89%
+Epoch   40/100 Cost: 0.507561 Accuracy 76.15%
+Epoch   50/100 Cost: 0.499125 Accuracy 76.42%
+Epoch   60/100 Cost: 0.493177 Accuracy 77.21%
+Epoch   70/100 Cost: 0.488846 Accuracy 76.81%
+Epoch   80/100 Cost: 0.485612 Accuracy 76.28%
+Epoch   90/100 Cost: 0.483146 Accuracy 76.55%
+Epoch  100/100 Cost: 0.481234 Accuracy 76.81%
+'''
+```
+
+학습이 정상적으로 된 것을 확인할 수 있다. 이때 accuracy는 `correct_prediction`에 맞았는지 틀렸는지를 저장해 평균을 내어 계산한다.
\ No newline at end of file
diff --git a/_posts/2022-05-01-dlZeroToAll-PyTorch-6.markdown b/_posts/2022-05-01-dlZeroToAll-PyTorch-6.markdown
new file mode 100644
index 00000000000..4f790a0142e
--- /dev/null
+++ b/_posts/2022-05-01-dlZeroToAll-PyTorch-6.markdown
@@ -0,0 +1,233 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab6: Softmax Classification"
+author: Kwon
+date: 2022-05-01T23:00:00 +0900
+categories: [pytorch, study]
+tags: [softmax-classification, multinomial-classification, cross-entropy]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab 6: Softmax Classification 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+## Softmax Classification(Multinomial Classification)
+[이전 포스팅](/posts/dlZeroToAll-PyTorch-5/)에서는 이진 분류 문제에 대해 알아봤다. 이번에는 분류해야 할 범주가 2개(0, 1)가 아니라 여러개인 다중 분류에 대해 알아보려 한다.
+
+### Hypothesis
+이진 분류는 다음과 같이 두 카테고리의 값들이 잘 나눠질 수 있는 선을 긋는 것과 같다.
+
+![](/posting_imgs/lab6-1.png){: width="40%"}
+
+이처럼 다중 분류도 여러 카테고리의 값들을 잘 나누는 선들을 긋는다고 생각해 보자. 그러면 다음과 같은 그림이 그려질 것이다.
+
+![](/posting_imgs/lab6-2.png){: width="40%"}
+
+파란색 선은 **A or not**, 빨간색 선은 **B or not** 그리고 초록색 선은 **C or not**으로 구분하고 있다고 생각하면 각 카테고리마다 하나의 분류 문제로 볼 수 있다.
+
+이 말은 각각의 카테고리를 분류하는 hypothesis를 정의할 수 있다는 것인데, 이를 다음과 같이 행렬의 연산으로 깔끔하게 나타낼 수 있다.
+
+![](/posting_imgs/lab6-3.png)
+
+이렇게 나온 확률을 각각 시그모이드로 처리하여 값을 낼 수도 있겠지만, 이때 조금 더 편하고 최적화된 함수로 softmax를 사용하게 되며 다음과 같이 정의된다.
+
+\\[ P(class=i) = \frac{e^i}{\sum e^i} \\]
+
+max를 soft하게 뽑는 것으로, 이 값이 최대인가, 아닌가로 단정지어 출력하는 것이 아니라 최대일 확률을 출력하는 거라고 이해하면 될것 같다.
+
+이렇게 뽑은 확률값으로 원-핫 인코딩하여 최종적으로 어느 카테고리에 속하는지 출력하게 된다. 아래 그림은 A 카테고리에 속한다고 생각할 때의 출력을 보인 것이다.
+
+![](/posting_imgs/lab6-4.png)
+
+코드로는 `torch`에서 제공하는 함수를 사용하면 된다.
+
+```python
+import torch
+import torch.nn.functional as F
+
+z = torch.FloatTensor([1, 2, 3])
+hypothesis = F.softmax(z, dim=0)
+print(hypothesis)
+
+'''output
+tensor([0.0900, 0.2447, 0.6652])
+'''
+```
+
+가장 큰 값인 3의 확률이 가장 크게(softmax) 출력된 것을 확인할 수 있다.
+
+<br><br>
+
+### Cost(Cross Entropy)
+
+hHypothesis까지 모두 정의했으니, 이제 그에 맞는 cost를 정의해야 한다. 다중 분류에서는 cross entropy를 cost로 사용하는데, 이는 간단히 말해서 예측한 확률이 실제 분포의 확률과 얼마나 차이가 나는지 계산한 값이다.
+
+자세한 내용은 이미 [cross entropy 포스팅](/posts/cross-entropy/)에서 다루었기 때문에 여기로 돌리고 바로 코드로 넘아가자. 실제 값을 원핫 인코딩 한 것에, softmax에 log를 취한 값을 원소별로 곱한 뒤에, 0이 아닌 값들은 평균내어 전체적인 cross entropy를 구할 수 있다.
+
+```python
+z = torch.rand(3, 5, requires_grad=True)
+hypothesis = F.softmax(z, dim=1)
+print(hypothesis)
+
+y = torch.randint(5, (3,)).long()
+print(y)
+
+y_one_hot = torch.zeros_like(hypothesis)
+y_one_hot.scatter_(1, y.unsqueeze(1), 1)
+
+cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean()
+print(cost)
+
+'''output
+tensor([[0.2645, 0.1639, 0.1855, 0.2585, 0.1277],
+        [0.2430, 0.1624, 0.2322, 0.1930, 0.1694],
+        [0.2226, 0.1986, 0.2326, 0.1594, 0.1868]], grad_fn=<SoftmaxBackward0>)
+
+tensor([0, 2, 1])
+
+tensor([[1., 0., 0., 0., 0.],
+        [0., 0., 1., 0., 0.],
+        [0., 1., 0., 0., 0.]])
+
+tensor(1.4689, grad_fn=<MeanBackward0>)
+'''
+
+아니면 softmax처럼 미리 구현되어 있는 것을 사용해도 된다.
+
+```python
+# -log를 취해서 평균내는 것까지만 torch 함수 사용 (Negative Log Likelihood)
+F.nll_loss(F.log_softmax(z, dim=1), y)
+
+# NLL과 softmax를 묶어 torch 함수로 사용
+F.cross_entropy(z, y)
+```
+
+***
+## Training data
+4차원의 input, 3가지의 class를 답으로 가진 데이터 셋이다.
+
+```python
+x_train = [[1, 2, 1, 1],
+           [2, 1, 3, 2],
+           [3, 1, 3, 4],
+           [4, 1, 5, 5],
+           [1, 7, 5, 5],
+           [1, 2, 5, 6],
+           [1, 6, 6, 6],
+           [1, 7, 7, 7]]
+y_train = [2, 2, 2, 1, 1, 1, 0, 0]
+x_train = torch.FloatTensor(x_train)
+y_train = torch.LongTensor(y_train)
+```
+
+***
+## Train
+Hypothesis와 cost이외에는 크게 달라진 점은 없다. 3가지 방식의 구현 코드만 한번 살펴보자
+
+<br>
+
+### `F.softmax` + `torch.log`
+```python
+W = torch.zeros((4, 3), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+
+optimizer = optim.SGD([W, b], lr=0.1)
+
+nb_epochs = 1000
+for epoch in range(nb_epochs + 1):
+
+    hypothesis = F.softmax(x_train.matmul(W) + b, dim=1)
+    y_one_hot = torch.zeros_like(hypothesis)
+    y_one_hot.scatter_(1, y_train.unsqueeze(1), 1)
+    cost = (y_one_hot * -torch.log(hypothesis)).sum(dim=1).mean()
+
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    # 100번마다 로그 출력
+    if epoch % 100 == 0:
+        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+            epoch, nb_epochs, cost.item()
+        ))
+
+'''output
+Epoch    0/1000 Cost: 1.098612
+Epoch  100/1000 Cost: 0.761050
+Epoch  200/1000 Cost: 0.689991
+Epoch  300/1000 Cost: 0.643229
+Epoch  400/1000 Cost: 0.604117
+Epoch  500/1000 Cost: 0.568255
+Epoch  600/1000 Cost: 0.533922
+Epoch  700/1000 Cost: 0.500291
+Epoch  800/1000 Cost: 0.466908
+Epoch  900/1000 Cost: 0.433507
+Epoch 1000/1000 Cost: 0.399962
+'''
+```
+
+<br><br>
+
+### `F.cross_entropy`
+softmax가 cross entropy에 속해 있기 때문에 hypothesis에는 softmax가 없는 모습을 볼 수 있다.
+
+```python
+W = torch.zeros((4, 3), requires_grad=True)
+b = torch.zeros(1, requires_grad=True)
+
+optimizer = optim.SGD([W, b], lr=0.1)
+
+nb_epochs = 1000
+for epoch in range(nb_epochs + 1):
+
+    z = x_train.matmul(W) + b
+    cost = F.cross_entropy(z, y_train)
+
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    if epoch % 100 == 0:
+        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+            epoch, nb_epochs, cost.item()
+        ))
+```
+
+<br><br>
+
+### `nn.Module`
+class를 정의하여 사용할 수도 있다.
+
+```python
+class SoftmaxClassifierModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = nn.Linear(4, 3) # Output이 3!
+
+    def forward(self, x):
+        return self.linear(x)
+```
+
+이때도 마찬가지로 softmax가 cross entropy에 속해 있기 때문에 class를 정의할 때는 선형 함수 부분만 정의해 준 것을 볼 수 있다.
+
+```python
+model = SoftmaxClassifierModel()
+
+optimizer = optim.SGD(model.parameters(), lr=0.1)
+
+nb_epochs = 1000
+for epoch in range(nb_epochs + 1):
+
+    prediction = model(x_train)
+
+    cost = F.cross_entropy(prediction, y_train)
+
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+    
+    if epoch % 100 == 0:
+        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+            epoch, nb_epochs, cost.item()
+        ))
+```
\ No newline at end of file
diff --git a/_posts/2022-05-04-autoencoders-3.markdown b/_posts/2022-05-04-autoencoders-3.markdown
new file mode 100644
index 00000000000..65a41c4fd52
--- /dev/null
+++ b/_posts/2022-05-04-autoencoders-3.markdown
@@ -0,0 +1,103 @@
+---
+title: "오토인코더의 모든 것 - 3. Autoencoders"
+author: Kwon
+date: 2022-05-04T00:00:00 +0900
+categories: [generative-model]
+tags: [autoencoder, dae, cae, scae]
+math: true
+mermaid: false
+---
+
+이활석님의 [오토인코더의 모든 것](https://www.youtube.com/watch?v=o_peo6U7IRM) 강의를 본 후 공부 및 정리를 목적으로 작성한 게시물임을 알려드립니다.
+
+***
+## Introduction
+### Autoencoder
+오토인코더는 인폿과 아웃풋이 같은 네트워크를 의미한다. Auto-associators, Diabolo nerworks, Sandglass-shaped net 등의 이명으로 불리기도 하며 가장 많이 불리는 이름은 역시 **Autoencoder**이다.
+
+![Autoencoder의 모습과 비슷한 Diabolo의 모습](/posting_imgs/diabolo.jpg)
+
+오토인코더는 다음과 같이 중간의 은닉층이 잘록한 모습의 네트워크인데, 이때 중간 은닉층을 $Z$라고 부르며 Code, Latent Variable, Feature, Hidden representation 등으로 불린다.
+그래서 $Z$를 어떻게 생각하냐에 따라 오토인코더에서 학습하는 과정을 Representation Learning, Efficient Code Learning 등으로 부르기도 하지만, 결국 이들은 모두 $Z$ 노드를 배우는 학습을 이르는 말들이다.
+
+![Autoencoder의 형태](/posting_imgs/autoencoder.png)
+
+처음 오토인코더가 각광받은 이유는 unsupervised learning 문제인 Demension Redection을 supervised learning으로 바꿔 풀 수 있다는 개념 때문이었다.
+최종 출력물이 원래의 입력과 같은 문제로 보고 학습을 한 후에, encoder 부분만 떼서 사용하면 차원축소가 가능한 네트워크를 얻을 수 있기 때문이다.
+
+이 경우 자기 자신에 대해 학습(self learning)하기 때문에 적어도 training DB에 있던 것들에 대해서는 압축을 잘 해준다. 즉, 최소 성능이 어느정도 보장된다는 장점이 있다.
+하지만 같은 이유로 새로운 것을 생성하려 해도 기존의 DB와 비슷한 결과가 많이 나온다는 평가를 듣기도 하였다.
+
+#### General AE(AutoEncoder) and Linear AE
+General AE를 조금 더 자세히 보자. 위에 나왔던 그림을 자세히 나타내면 다음과 같다.
+
+![General Autoencoder](/posting_imgs/autoencoder-loss.png)
+
+최종 출력 $Y$는 인코더의 출력은 디코더에 인풋으로 넣어 나온 output으로 정의할 수 있고, 이것이 첫 input $X$와 같기를 바라므로 이들끼리의 error를 구한다.
+이때는 데이터의 분포 형태에 따라 MSE 또는 [cross-entropy](/posts/cross-entropy/)를 사용한다.
+이렇게 구한 error를 재구축(reconstruct) 한 것에 대한 error라는 의미로 **Reconstruction Error**라고 한다.
+
+Linear AE는 기본적인 오토인코더의 구조에서 은닉층을 활성화 함수 없이 선형 함수를 그대로 사용한 것을 말한다.
+PCA(Principle Component Analysis)와 baisis는 다르지만 선형적으로 차원 축소를 진행하기 때문에 결과적으로 PCA와 같은 mainifold를 학습한다는 특징이 있다.
+
+***
+## Pretraining
+### Stacking AE
+현재의 CNN, DNN 방법론들에 비해 예전의 방법론들은 적절한 parameter 초기화가 어려웠다. 이때 오토인코더로 pretraining을 하니 성능 개선이 이루어졌다고 해서 사용되기 시작한 방식이다.
+pretraining 방식은 다음과 같다.
+
+![Stacking Autoencoder](/posting_imgs/stacking-autoencoder.png)
+
+먼저 원하는 차원으로 보낸 후, 원래 레이어로 돌아와서 제대로 복구가 되는지 확인한다. 이 과정에서 오토인코더 구조가 사용된다.
+적어도 input layer의 값들을 복구할 수 있는 prameter를 사용하자는 것이다. 이 과정을 모든 레이어에 대해 진행하면서 prameter를 고정한다.
+
+학습이 모두 끝난 뒤에는 random inintialization으로 backpropagation한다.
+
+***
+## DAE(Denoising AE)
+원래의 오토인코더 방식으로 학습을 하되 input 데이터에 noise를 추가하여 학습하는 방식이다. 이때 핵심은 noise를 (이미지 같은 것을) 사람이 봤을 때 다르지 않을 정도만 추가한다는 것이다.
+
+이런 식으로 학습을 하면 사람이 봤을 때 같은 것(manifold상 거의 같은 것)이 무엇인지 학습할 수 있게 된다는 concept이다.
+
+![](/posting_imgs/dae.png" description="Denoising Autoencoder" %}
+
+noise를 추가하고 noise가 없는 원래 데이터와 error를 구하면서 manifold 상 같은 것이 뭔지 학습하는 구조이다.
+
+실제로 이렇게 noise를 추가하여 학습한 결과 이미지의 특징을 찾는 edge detection이 잘 된 모습을 확인할 수 있다. 자세한 것은 다음 [링크](http://videolectures.net/deeplearning2015_vincent_autoencoders/?q=vincent%20autoencoder)에서 확인할 수 있다.
+
+![](/posting_imgs/dae-sample1.png" description="DAE와 다른 AE들과의 edge 비교" %}
+
+또한 noise를 추가할수록 edge가 강하게 나타나는 것도 확인할 수 있다.
+
+![](/posting_imgs/dae-sample2.png" description="noise 정도에 따른 edge 비교" %}
+
+다만 noise 추가가 너무 심해 원본의 데이터와 manifold 상에서 차이가 많이 나게 되면, noise를 추가한 의미가 퇴색되기 때문에 일정 noise 이상에서는 error가 다시 높아지는 것을 볼 수 있다.
+
+![](/posting_imgs/dae-graph.png" description="noise-error graph" %}
+
+***
+## CAE(Cntractive AE)
+### Stochastic Contractive AE(SCAE)
+DAE에서 loss의 의미를 해석하여 다르게 표현한 것이다. DAE의 loss를 생각해 보면 $g$, $h$중 $h$는 특히 데이터가 조금만 바뀌1어도 manifold 상에서 같은 smaple로 매칭이 되게 학습을 해야 한다고 볼 수 있다.
+이 의미를 재구성 해보면 다음과 같이 적을 수 있다.
+
+![](/posting_imgs/scae.png){: width="80%"}
+
+reconstruction error를 통해 원래 오토인코더의 형태대로 입출력이 동일하게 학습하고, **stochastic regularization**항을 통해 manifold 상에서 거리가 같게 학습하도록 loss를 구성하였다.
+
+### CAE
+SCAE의 stochastic regularization 항을 테일러 전개를 통해 근사하여, Frobenius norm 형태로 만들어, analytic regularization로 적용한 것이 CAE이다.
+하지만 1차 미분 항에서 끊어 근사한 것이므로 한 지점의 근처에서만 유의미한 근사가 된다고 할 수 있다.
+
+![](/posting_imgs/cae-regular.png){: width="80%"}
+
+위 식으로 regularization 항을 대체하여 다음과 같이 CAE loss를 적용한다.
+
+![](/posting_imgs/cae.png){: width="80%"}
+
+#### DAE vs CAE
+결국 DAE와 CAE의 concept 자체는 mainfold 위의 거리를 줄인다는 것으로 같지만, 그것을 적용하는 방식이 달랐다.
+
+DAE의 경우 noise가 첨가된 input으로 학습하여 manifold 상의 거리를 좁히려 했다면, CAE는 regularization을 통해 이를 해결하려 했다.
+
+실제로는 CAE보다 DAE가 더 많이 쓰인다고 한다. 참고로 **AE, DAE, VAE(Variational AE)**가 많이 쓰이는 오토인코더 종류라고 한다.
\ No newline at end of file
diff --git a/_posts/2022-05-07-dlZeroToAll-PyTorch-7-1.markdown b/_posts/2022-05-07-dlZeroToAll-PyTorch-7-1.markdown
new file mode 100644
index 00000000000..ce8be0ce66b
--- /dev/null
+++ b/_posts/2022-05-07-dlZeroToAll-PyTorch-7-1.markdown
@@ -0,0 +1,334 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab7-1: Tips"
+author: Kwon
+date: 2022-05-07T23:00:00 +0900
+categories: [pytorch, study]
+tags: [mle, overfitting, regularization, learning-rate]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab7-1: Tips 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Maximum Likelihood Estimate(MLE)
+
+### Probalility vs Likelihood
+
+Probalility(확률)는 우리가 잘 알고 있듯이 어떤 관측값이 발생할 정도를 뜻하는데, 이는 다르게 말하면 한 확률분포에서 해당 관측값 또는 관측 구간이 얼마의 확률을 가지는가를 뜻한다. 이에 반해 Likelihood(우도, 가능도)는 이 관측값이 주어진 확률 분포에서 확률이 얼마나 되는지를 말한다.
+
+중요한 차이점은 **확률**은 이미 배경이 되는 확률 분포가 **고정**되어 있고, **우도**는 **고정되어 있지 않다**는 것이다.
+
+### MLE
+
+이런 의미를 가진 우도를 최대화 한다는 것은 관측된 결과에 맞는 확률 분포를 찾아낸다는 것으로 생각할 수 있다.
+
+베르누이 분포를 예로 들면 확률분포를 결정하는 아래와 같은 상황에서 $\theta$를 변화시키면서 주어진 값에 맞춰 확률 분포를 최적화 하는 것이다.
+
+![](/posting_imgs/lab7-1-1.jpg){: width="40%"}
+
+최적화 하는 과정은 마찬가지로 gradient descent(ascent)를 통해 진행한다.
+
+***
+
+## Overfitting
+
+아래와 같이 Train set에 대해 과하게 맞춰 학습한 것을 말한다. 이 경우 학습할 때 사용한 데이터 셋이 아닌 데이터가 주어졌을 때의 예측 성능이 급격하게 떨어지게 된다.
+
+![](/posting_imgs/lab7-1-2.jpg){: width="60%"}
+
+이러한 overfitting(과적합)을 막기 위해 test set과 vaild set을 사용하게 된다. 학습을 할 때 한 번도 보지 못했던 set을 이용하여 과적합 여부를 확인하는 것이다.
+
+![](/posting_imgs/lab7-1-3.jpg){: width="60%"}
+
+위와 같이 train set에 대한 loss는 감소하지만 valid set에 대한 loss가 감소하지 않을 때 과적합이 발생한다고 판단할 수 있다.
+
+### Regularization
+
+과적합을 막기 위한 방법에는 더 많은 데이터를 사용한다거나, 더 적은 feature를 사용하는 방법 등 여러 방법이 있고, 그 중 하나가 regularization이다.
+
+**Regularization**에는 다음과 같은 방법들이 있다.
+
+* Early Stoping: valid set의 loss가 줄어들지 않을 때 학습을 중지한다.
+* Reducing Network Size
+* Weight Decay: weight가 너무 커지지 않도록 wight가 커질수록 함께 커지는 penalty를 부여한다.
+* Dropout: node의 일부를 꺼서 학습하는 node를 줄인다.
+* Batch Normalization: 학습 중에 배치 단위로 정규화 하는 것
+
+***
+
+## with Code
+
+### Import
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+# 시드 고정
+ torch.manual_seed(1)
+```
+
+### Data
+
+3차원의 input과 3개의 class를 가지고 있는 label로 학습을 진행하며, train set과 test set의 비율은 8:3이다.
+
+```python
+# train set
+x_train = torch.FloatTensor([[1, 2, 1],
+                             [1, 3, 2],
+                             [1, 3, 4],
+                             [1, 5, 5],
+                             [1, 7, 5],
+                             [1, 2, 5],
+                             [1, 6, 6],
+                             [1, 7, 7]
+                            ])
+y_train = torch.LongTensor([2, 2, 2, 1, 1, 1, 0, 0])
+
+# test set
+x_test = torch.FloatTensor([[2, 1, 1], [3, 1, 2], [3, 3, 4]])
+y_test = torch.LongTensor([2, 2, 2])
+```
+
+### Model
+
+[lab6](/posts/dlZeroToAll-PyTorch-6/)에서 다뤘던 softamx model을 사용하여 학습을 진행한다.
+
+물론 입출력 차원은 맞춰줘야 하기 때문에 `self.linear = nn.Linear(3, 3)`로 선형 모델을 정의하는 부분만 달라졌다.
+
+```python
+class SoftmaxClassifierModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = nn.Linear(3, 3)
+    def forward(self, x):
+        return self.linear(x)
+
+model = SoftmaxClassifierModel()
+```
+
+### Train
+
+이 부분 역시 기존의 틀을 벗어나지 않는다.
+
+```python
+# optimizer 설정
+optimizer = optim.SGD(model.parameters(), lr=0.1)
+
+def train(model, optimizer, x_train, y_train):
+    nb_epochs = 20
+    for epoch in range(nb_epochs):
+
+        # H(x) 계산
+        prediction = model(x_train)
+
+        # cost 계산
+        cost = F.cross_entropy(prediction, y_train)
+
+        # cost로 H(x) 개선
+        optimizer.zero_grad()
+        cost.backward()
+        optimizer.step()
+
+        print('Epoch {:4d}/{} Cost: {:.6f}'.format(
+            epoch, nb_epochs, cost.item()
+        ))
+
+def test(model, optimizer, x_test, y_test):
+    prediction = model(x_test)
+    predicted_classes = prediction.max(1)[1]
+    correct_count = (predicted_classes == y_test).sum().item()
+    cost = F.cross_entropy(prediction, y_test)
+
+    print('Accuracy: {}% Cost: {:.6f}'.format(
+         correct_count / len(y_test) * 100, cost.item()
+    ))
+
+train(model, optimizer, x_train, y_train)
+
+test(model, optimizer, x_test, y_test)
+
+'''output
+Epoch    0/20 Cost: 2.203667
+Epoch    1/20 Cost: 1.199645
+Epoch    2/20 Cost: 1.142985
+Epoch    3/20 Cost: 1.117769
+Epoch    4/20 Cost: 1.100901
+Epoch    5/20 Cost: 1.089523
+Epoch    6/20 Cost: 1.079872
+Epoch    7/20 Cost: 1.071320
+Epoch    8/20 Cost: 1.063325
+Epoch    9/20 Cost: 1.055720
+Epoch   10/20 Cost: 1.048378
+Epoch   11/20 Cost: 1.041245
+Epoch   12/20 Cost: 1.034285
+Epoch   13/20 Cost: 1.027478
+Epoch   14/20 Cost: 1.020813
+Epoch   15/20 Cost: 1.014279
+Epoch   16/20 Cost: 1.007872
+Epoch   17/20 Cost: 1.001586
+Epoch   18/20 Cost: 0.995419
+Epoch   19/20 Cost: 0.989365
+
+Accuracy: 0.0% Cost: 1.425844
+'''
+```
+
+임의로 넣은 값들이라 예측의 의미는 크게 없어 보인다. 모델을 어떻게 학습하는지에 대한 코드만 참고하면 될 것 같다.
+
+***
+
+## Learning Rate
+
+\\[ W := W - \alpha \nabla W \,\,\left(\alpha = learning\,\,rate\right)\\]
+
+위와 같은 gradient descent 식에서 $\alpha$가 learning rate(학습률)이다. 학습하는 비율이라고 간단하게 언급하고 넘어갔었는데, 이번에는 어떤 영향을 미치는지 확인해 보자.
+
+```python
+model = SoftmaxClassifierModel()
+optimizer = optim.SGD(model.parameters(), lr=1e5)
+train(model, optimizer, x_train, y_train)
+
+'''output
+Epoch    0/20 Cost: 1.280268
+Epoch    1/20 Cost: 976950.812500
+Epoch    2/20 Cost: 1279135.125000
+Epoch    3/20 Cost: 1198379.000000
+Epoch    4/20 Cost: 1098825.875000
+Epoch    5/20 Cost: 1968197.625000
+Epoch    6/20 Cost: 284763.250000
+Epoch    7/20 Cost: 1532260.125000
+Epoch    8/20 Cost: 1651504.000000
+Epoch    9/20 Cost: 521878.500000
+Epoch   10/20 Cost: 1397263.250000
+Epoch   11/20 Cost: 750986.250000
+Epoch   12/20 Cost: 918691.500000
+Epoch   13/20 Cost: 1487888.250000
+Epoch   14/20 Cost: 1582260.125000
+Epoch   15/20 Cost: 685818.062500
+Epoch   16/20 Cost: 1140048.750000
+Epoch   17/20 Cost: 940566.500000
+Epoch   18/20 Cost: 931638.250000
+Epoch   19/20 Cost: 1971322.625000
+'''
+```
+
+학습률이 너무 큰 경우이다. 학습률이 크면 한번에 학습하려는 정도가 커지는데 이 정도가 너무 크게 되면, 점점 gradient가 커지면서 발산(overshooting)하게 된다.
+
+위 코드의 결과를 보면 cost가 학습할 수록 커지고 있는 것을 확인할 수 있다.
+
+```python
+model = SoftmaxClassifierModel()
+optimizer = optim.SGD(model.parameters(), lr=1e-10)
+train(model, optimizer, x_train, y_train)
+
+'''output
+Epoch    0/20 Cost: 3.187324
+Epoch    1/20 Cost: 3.187324
+Epoch    2/20 Cost: 3.187324
+Epoch    3/20 Cost: 3.187324
+Epoch    4/20 Cost: 3.187324
+Epoch    5/20 Cost: 3.187324
+Epoch    6/20 Cost: 3.187324
+Epoch    7/20 Cost: 3.187324
+Epoch    8/20 Cost: 3.187324
+Epoch    9/20 Cost: 3.187324
+Epoch   10/20 Cost: 3.187324
+Epoch   11/20 Cost: 3.187324
+Epoch   12/20 Cost: 3.187324
+Epoch   13/20 Cost: 3.187324
+Epoch   14/20 Cost: 3.187324
+Epoch   15/20 Cost: 3.187324
+Epoch   16/20 Cost: 3.187324
+Epoch   17/20 Cost: 3.187324
+Epoch   18/20 Cost: 3.187324
+Epoch   19/20 Cost: 3.187324
+'''
+```
+
+이번에는 학습률이 너무 작은 경우이다. 이 때는 발산할 확률은 거의 없겠지만 학습이 너무 느리거나 진행이 되지 않는다.
+
+위 코드에서 보면 cost가 변하지 않는 것을 확인할 수 있다.
+
+그래서 적절한 학습률을 찾기 위해서는 발산하면 작게, cost가 줄어들지 않으면 크게 조정하는 것이 바람직하다.
+
+***
+
+## Data Preprocessing
+
+학습이 잘 될 수 있도록 data를 학습 전에 처리해 주는 것을 Data Preprocessing(데이터 전처리)이라고 한다.
+
+### Standardization
+
+이런 전처리 중 하나인 Standardization(정규화)을 한번 알아보자. 정규화의 식은 다음과 같이 주어진다.
+
+\\[ x'_j = \frac{x_j - \mu_j}{\sigma_j} \\]
+
+여기서 $\sigma$는 표준 분산, $\mu$는 평균을 의미한다. 이들을 코드로 표현하면 다음과 같다.
+
+```python
+mu = x_train.mean(dim=0)
+sigma = x_train.std(dim=0)
+norm_x_train = (x_train - mu) / sigma
+
+print(norm_x_train)
+
+'''output
+tensor([[-1.0674, -0.3758, -0.8398],
+        [ 0.7418,  0.2778,  0.5863],
+        [ 0.3799,  0.5229,  0.3486],
+        [ 1.0132,  1.0948,  1.1409],
+        [-1.0674, -1.5197, -1.2360]])
+'''
+```
+
+이걸 이용해서 training을 하려면 다음과 같은 결과가 나온다.
+
+```
+train(model, optimizer, norm_x_train, y_train)
+
+'''output
+Epoch    0/20 Cost: 29785.091797
+Epoch    1/20 Cost: 18906.164062
+Epoch    2/20 Cost: 12054.674805
+Epoch    3/20 Cost: 7702.029297
+Epoch    4/20 Cost: 4925.733398
+Epoch    5/20 Cost: 3151.632568
+Epoch    6/20 Cost: 2016.996094
+Epoch    7/20 Cost: 1291.051270
+Epoch    8/20 Cost: 826.505310
+Epoch    9/20 Cost: 529.207336
+Epoch   10/20 Cost: 338.934204
+Epoch   11/20 Cost: 217.153549
+Epoch   12/20 Cost: 139.206741
+Epoch   13/20 Cost: 89.313782
+Epoch   14/20 Cost: 57.375462
+Epoch   15/20 Cost: 36.928429
+Epoch   16/20 Cost: 23.835772
+Epoch   17/20 Cost: 15.450428
+Epoch   18/20 Cost: 10.077808
+Epoch   19/20 Cost: 6.633700
+'''
+```
+
+정규화가 하려는 학습에 정말 좋은지는 학습하여 결과를 확인하는 것이 가장 좋겠지만, 이론적으로 분석을 하면 data 차원 간의 값의 차이가 크다거나 할 때 진행하면 좋은 효과를 볼 수 있다.
+
+```python
+y = torch.FloatTensor([[0.0011, 2000, 1],
+                             [0.001, 3000, 2],
+                             [0.0001, 3000, 4],
+                             [0.0021, 5000, 5],
+                             [0.0131, 7000, 5],
+                             [0.0211, 2000, 5],
+                             [0.1211, 6000, 6],
+                             [0.0001, 7000, 7]
+                            ])
+```
+
+예를 들어 위와 같은 target이 있다. 이 데이터의 값을 차원별로 비교해 보면, 그 차이가 너무 큰 것을 볼 수 있다.
+이렇게 되어버리면 2번째 값(1000 단위)에 대한 loss를 최소화 하는 것이 훨씬 이득이라고 생각하여 다른 값들에 대한 학습이 제대로 되지 않을 수 있다.
+
+이때 정규화를 통해 적절한 범위로 값을 잡아주면 모든 데이터들이 균등하게 학습이 될 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-05-10-dlZeroToAll-PyTorch-7-2.markdown b/_posts/2022-05-10-dlZeroToAll-PyTorch-7-2.markdown
new file mode 100644
index 00000000000..dcd7ec02a41
--- /dev/null
+++ b/_posts/2022-05-10-dlZeroToAll-PyTorch-7-2.markdown
@@ -0,0 +1,162 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab7-2: MNIST Intoduction"
+author: Kwon
+date: 2022-05-10T23:00:00 +0900
+categories: [pytorch, study]
+tags: [mnist]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab7-2: MNIST Intoduction 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## MNIST dataset
+
+MNIST 데이터 셋은 숫자 손글씨를 모아놓은 데이터 셋이다. 사람들이 적은 숫자들을 우체국에서 자동으로 처리하기 위해 만들어진 것이 이 셋의 시작점이라고 한다.
+
+MNIST는 다음과 같이 28x28 크기의 픽셀, 1개의 gray channel 그리고 0 ~ 9의 정수 label로 이루어져 있다.
+
+![](/posting_imgs/lab7-2-1.png)
+
+### torchvision
+
+minist는 torchvision 모듈을 통해 불러온다. torchvision은 여러 데이터 셋이나 아키텍처, 전처리를 할 수 있는 기능들을 내장하고 있는 모듈이다.
+
+```python
+import torch
+import torchvision.datasets as dsets
+import torchvision.transforms as transforms
+import matplotlib.pyplot as plt
+
+# parameters
+training_epochs = 15
+batch_size = 100
+
+# MNIST dataset
+mnist_train = dsets.MNIST(root='MNIST_data/',
+                          train=True, # train set
+                          transform=transforms.ToTensor(),
+                          download=True)
+
+mnist_test = dsets.MNIST(root='MNIST_data/',
+                         train=False, # test set
+                         transform=transforms.ToTensor(),
+                         download=True)
+
+# minibatch
+data_loader - torch.utils.DataLoader(DataLoader=mnist_train, batch_size=batch_size, shuffle=True, drop_last=True)
+```
+
+mnist는 60000개의 train set과 10000개의 test set으로 구성되어 있고, train prameter에 boolean 값을 넣어 각 셋을 불러올 수 있다.
+
+다른 데이터 셋들과 마찬가지로 `DataLoader`를 통해 미니배치를 나누어 학습할 수 있다.
+
+### Model
+
+```python
+# MNIST data image of shape 28 * 28 = 784
+linear = torch.nn.Linear(784, 10, bias=True).to(device)
+
+# define cost/loss & optimizer
+criterion = torch.nn.CrossEntropyLoss().to(device)
+optimizer = torch.optim.SGD(linear.parameters(), lr=0.1)
+```
+
+모델은 선형모델을 사용하며 이미지의 크기가 28x28이므로 28*28=784의 차원을 가지는 입력을 받도록 정의한다.
+
+### Train
+```python
+for epoch in range(training_epochs):
+    avg_cost = 0
+    total_batch = len(data_loader)
+
+    for X, Y in data_loader:
+        # reshape input image into [batch_size by 784]
+        # label is not one-hot encoded
+        X = X.view(-1, 28 * 28).to(device)
+        Y = Y.to(device)
+
+        hypothesis = linear(X)
+        cost = criterion(hypothesis, Y)
+        
+        optimizer.zero_grad()
+        cost.backward()
+        optimizer.step()
+
+        avg_cost += cost / total_batch
+
+    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
+
+print('Learning finished')
+
+'''output
+Epoch: 0001 cost = 0.535468459
+Epoch: 0002 cost = 0.359274179
+Epoch: 0003 cost = 0.331187516
+Epoch: 0004 cost = 0.316578031
+Epoch: 0005 cost = 0.307158142
+Epoch: 0006 cost = 0.300180674
+Epoch: 0007 cost = 0.295130163
+Epoch: 0008 cost = 0.290851504
+Epoch: 0009 cost = 0.287417084
+Epoch: 0010 cost = 0.284379542
+Epoch: 0011 cost = 0.281825215
+Epoch: 0012 cost = 0.279800713
+Epoch: 0013 cost = 0.277809024
+Epoch: 0014 cost = 0.276154280
+Epoch: 0015 cost = 0.274440825
+Learning finished
+'''
+```
+
+[Lab4-2](/posts/dlZeroToAll-PyTorch-4_2/)에서 학습한 방식과 같이 `data_loader`를 for를 통해 반복하며 진행한다.
+
+이때 기존의 이미지 데이터의 minibatch는 `[batch_size, 1, 28, 28]`의 크기를 가지기 때문에, 모델의 입력에 맞게 `[batch_size, 28*28]`로 바꿔주는 과정이 필요하다. 이 과정을 위해 `X = X.view(-1, 28 * 28).to(device)`로 데이터를 재구성한 것을 볼 수 있다.
+
+나머지는 학습은 기존의 형태와 동일하다.
+
+### Test
+
+테스트를 진행할 때에는 이미 학습된 모델에 대해 학습이 잘 되었는지를 확인하는 것이기 때문에 gradient descent로 인한 가중치 업데이트가 되면 안된다.
+그래서 `with torch.no_grad()`{:.python} 안에서 업데이트 되는 것을 막으면서 테스트를 진행한다.
+
+```python
+# Test the model using test sets
+with torch.no_grad():
+    X_test = mnist_test.test_data.view(-1, 28 * 28).float().to(device)
+    Y_test = mnist_test.test_labels.to(device)
+
+    prediction = linear(X_test)
+    correct_prediction = torch.argmax(prediction, 1) == Y_test
+    accuracy = correct_prediction.float().mean()
+    print('Accuracy:', accuracy.item())
+
+    # Get one and predict
+    r = random.randint(0, len(mnist_test) - 1)
+    X_single_data = mnist_test.test_data[r:r + 1].view(-1, 28 * 28).float().to(device)
+    Y_single_data = mnist_test.test_labels[r:r + 1].to(device)
+
+    print('Label: ', Y_single_data.item())
+    single_prediction = linear(X_single_data)
+    print('Prediction: ', torch.argmax(single_prediction, 1).item())
+
+    plt.imshow(mnist_test.test_data[r:r + 1].view(28, 28), cmap='Greys', interpolation='nearest')
+    plt.show()
+
+'''output
+Accuracy: 0.8862999677658081
+Label:  8
+Prediction:  3
+'''
+```
+
+![](/posting_imgs/lab7-2-1.png)
+
+학습한 모델에 test 입력을 통과시켜 나온 결과를 `argmax`를 통해 모델이 예측한 label을 뽑아낼 수 있다.
+이후 test의 실제 label과 비교하여 ByteTensor를 생성하고, 그 평균을 구해 정확도를 계산할 수 있다.
+
+한 데이터에 대한 출력값은 싶다면 test_data와 label을 슬라이싱 하여 모델에 넣어서 결과값을 출력하는 것으로 확인할 수 있다.
+
+그 데이터에 대한 이미지는 `plt.imshow`를 통해 롹인할 수 있다. cmap(color map)을 grey로 설정하고, interpolation(보간)을 nearest로 하면 mnist 이미지를 얻을 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-05-11-dlZeroToAll-PyTorch-8-1.markdown b/_posts/2022-05-11-dlZeroToAll-PyTorch-8-1.markdown
new file mode 100644
index 00000000000..a5cc3c3af69
--- /dev/null
+++ b/_posts/2022-05-11-dlZeroToAll-PyTorch-8-1.markdown
@@ -0,0 +1,120 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab8-1: Perceptron"
+author: Kwon
+date: 2022-05-11T23:00:00 +0900
+categories: [pytorch, study]
+tags: [perceptron]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab8-1: Perceptron 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Neuron
+
+먼저 퍼셉트론의 컨셉이 된 뉴런에 대해 알아보자. 뉴런은 동물의 신경계를 구성하는 세포로 다음과 같은 형태이다.
+
+![동물의 뉴런](/posting_imgs/lab8-1-1.svg)
+
+뉴런은 자극을 전기 신호를 전달하는 통로라고 할 수 있는데, 이때 강도가 어느 정도(threshold)를 넘어서는 신호만을 전달한다.
+
+***
+
+## Perceptron
+
+퍼셉트론은 이런 뉴런의 작동 방식을 반영하여 만든 인공신경망의 한 종류로, 다수의 입력을 받아 하나의 출력을 내보내는 구조이다.
+
+![퍼셉트론의 구조](/posting_imgs/lab8-1-2.png)
+
+처음 퍼셉트론이 등장했을 때는 AND, OR 문제를 아주 잘 해결하였다. 다음 그래프를 보면 AND, OR 문제 모두 선형으로 잘 분리되는 것을 볼 수 있다.
+
+![AND(좌)와 OR(우)의 분류 형태](/posting_imgs/lab8-1-3.jpg)
+
+그래서 더 복잡한 문제도 풀어낼 수 있지 않을까 하며 기대를 받았었는데, XOR 문제가 단일 퍼셉트론으로 해결할 수 없다는 것이 증명되면서 퍼셉트론 연구에 암흑기가 도래하게 되었다.
+
+![단일 선형으로 해결할 수 없는 XOR](/posting_imgs/lab8-1-4.jpg)
+
+위 그림을 보면 어떤 직선을 그어도 하나의 직선으로는 XOR 문제를 명확하게 가를 수 없는 것을 볼 수 있다.
+실제로도 그런지 코드로 학습해 보면서 한번 확인 해 보자.
+
+### XOR train code with single preceptron
+
+모델은 선형에 시그모이드를 활성화 함수로 사용하도록 하고, 이진분류이므로 손실함수로 `BECLoss`를 사용한다.
+
+```python
+import torch
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+# 시드 고정
+torch.manual_seed(777)
+if device == 'cuda':
+    torch.cuda.manual_seed_all(777)
+
+X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]]).to(device)
+Y = torch.FloatTensor([[0], [1], [1], [0]]).to(device)
+```
+
+먼저 XOR에 대한 데이터를 정의해 준다.
+
+```python
+linear = torch.nn.Linear(2, 1, bias=True)
+sigmoid = torch.nn.Sigmoid()
+
+# Sequential로 여러 모듈을 묶어 하나의 레이어로 사용
+model = torch.nn.Sequential(linear, sigmoid).to(device)
+
+criterion = torch.nn.BCELoss().to(device)
+optimizer = torch.optim.SGD(model.parameters(), lr=1)
+
+'''output
+0 0.7273974418640137
+100 0.6931475400924683
+200 0.6931471824645996
+300 0.6931471824645996
+400 0.6931471824645996
+500 0.6931471824645996
+600 0.6931471824645996
+...
+9700 0.6931471824645996
+9800 0.6931471824645996
+9900 0.6931471824645996
+10000 0.6931471824645996
+'''
+```
+
+100epoch 부터 loss가 잘 감소하지 않더니 200부터는 아예 감소하지 않는다. 확실히 확인해 보기 위해 정확도를 출력해 보면
+
+```python
+with torch.no_grad():
+    hypothesis = model(X)
+    predicted = (hypothesis > 0.5).float()
+    accuracy = (predicted == Y).float().mean()
+    print('\nHypothesis: ', hypothesis.detach().cpu().numpy(), '\nCorrect: ', predicted.detach().cpu().numpy(), '\nAccuracy: ', accuracy.item())
+
+'''output
+Hypothesis:  [[0.5]
+ [0.5]
+ [0.5]
+ [0.5]] 
+Correct:  [[0.]
+ [0.]
+ [0.]
+ [0.]] 
+Accuracy:  0.5
+'''
+```
+
+모든 hypothesis 결과가 0.5로 나오는 것을 확인할 수 있다. 이처럼 단일 퍼셉트론으로는 XOR을 제대로 분류할 수 없다.
+
+다음 포스팅에서는 XOR을 해결한 Multi Layer Percetron에 대해 알아보겠다.
+
+***
+
+#### Image source
+
+* Neuron: [https://commons.wikimedia.org/wiki/File:Neuron.svg](https://commons.wikimedia.org/wiki/File:Neuron.svg)
+
+* Perceptron: [https://commons.wikimedia.org/wiki/File:Rosenblattperceptron.png](https://commons.wikimedia.org/wiki/File:Rosenblattperceptron.png)
\ No newline at end of file
diff --git a/_posts/2022-05-12-dlZeroToAll-PyTorch-8-2.markdown b/_posts/2022-05-12-dlZeroToAll-PyTorch-8-2.markdown
new file mode 100644
index 00000000000..ffd102d8e12
--- /dev/null
+++ b/_posts/2022-05-12-dlZeroToAll-PyTorch-8-2.markdown
@@ -0,0 +1,163 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab8-2: Multi Layer Perceptron"
+author: Kwon
+date: 2022-05-12T23:00:00 +0900
+categories: [pytorch, study]
+tags: [perceptron]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab8-2: Multi Layer Perceptron 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## MLP(Multi Layer Perceptron)
+
+MLP는 단일 퍼셉트론을 여러개 쌓은 것으로 단일 퍼셉트론으로 해결하지 못한 XOR과 같은 문제를 해결하기 위해 제안된 구조이다.
+
+![](/posting_imgs/lab8-2-1.jpg)
+
+위와 같이 XOR 문제는 선을 2개 그어 문제를 해결할 수 있는데, 한동안 MLP를 현실적으로 학습할 수 있는 방법을 찾지 못하다가 **backpropagation**이 등장하면서 힉습이 가능해졌다.
+
+***
+
+## Data and Model
+
+```python
+import torch
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+# 시드 고정
+torch.manual_seed(777)
+if device == 'cuda':
+    torch.cuda.manual_seed_all(777)
+
+X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]]).to(device)
+Y = torch.FloatTensor([[0], [1], [1], [0]]).to(device)
+```
+
+위와 같이 데이터를 XOR에 맞게 만들어 주고, 모델도 생성해 준다. 이번에는 MLP로 학습할 것이기 때문에 선형 레이어 2개를 만들어 `Sequential`로 묶어 준다.
+loss는 마찬가지로 이진분류이므로 `BCELoss`를 사용한다.
+
+```python
+linear1 = torch.nn.Linear(2, 2, bias=True)
+linear2 = torch.nn.Linear(2, 1, bias=True)
+sigmoid = torch.nn.Sigmoid()
+
+model = torch.nn.Sequential(linear1, sigmoid, linear2, sigmoid).to(device)
+
+criterion = torch.nn.BCELoss().to(device)
+optimizer = torch.optim.SGD(model.parameters(), lr=1)
+```
+
+***
+
+## Train
+
+학습 코드의 형태는 동일하다.
+
+```python
+for step in range(10001):
+    hypothesis = model(X)
+
+    # cost/loss function
+    cost = criterion(hypothesis, Y)
+
+    optimizer.zero_grad()
+    cost.backward()
+    optimizer.step()
+
+    if step % 100 == 0:
+        print(step, cost.item())
+
+'''output
+0 0.7434073090553284
+100 0.6931650638580322
+200 0.6931577920913696
+300 0.6931517124176025
+400 0.6931463479995728
+500 0.6931411027908325
+600 0.693135678768158
+700 0.6931295394897461
+800 0.693122148513794
+900 0.6931126713752747
+1000 0.6930999755859375
+...
+9700 0.001285637030377984
+9800 0.0012681199004873633
+9900 0.0012511102249845862
+10000 0.0012345188297331333
+'''
+```
+
+조금씩이지만 확실히 loss가 줄어드는 것을 확인할 수 있다. 정확도도 한번 출력해 보자.
+
+```python
+with torch.no_grad():
+    hypothesis = model(X)
+    predicted = (hypothesis > 0.5).float()
+    accuracy = (predicted == Y).float().mean()
+    print('\nHypothesis: ', hypothesis.detach().cpu().numpy(), '\nCorrect: ', predicted.detach().cpu().numpy(), '\nAccuracy: ', accuracy.item())
+
+'''output
+
+Hypothesis:  [[0.00106364]
+ [0.99889404]
+ [0.99889404]
+ [0.00165861]] 
+Correct:  [[0.]
+ [1.]
+ [1.]
+ [0.]] 
+Accuracy:  1.0
+'''
+```
+
+XOR을 아주 잘 분류해 준다. 이번 학습에서는 2개의 레이어만을 쌓았지만 여러개의 레이어, 또는 더 노드가 많은 레이어도 만들 수 있다.
+
+### NN Wide Deep
+
+```python
+linear1 = torch.nn.Linear(2, 10, bias=True)
+linear2 = torch.nn.Linear(10, 10, bias=True)
+linear3 = torch.nn.Linear(10, 10, bias=True)
+linear4 = torch.nn.Linear(10, 1, bias=True)
+sigmoid = torch.nn.Sigmoid()
+
+model = torch.nn.Sequential(linear1, sigmoid, linear2, sigmoid, linear3, sigmoid, linear4, sigmoid).to(device)
+
+for step in range(10001):
+    optimizer.zero_grad()
+    hypothesis = model(X)
+
+    # cost/loss function
+    cost = criterion(hypothesis, Y)
+    cost.backward()
+    optimizer.step()
+
+    if step % 100 == 0:
+        print(step, cost.item())
+
+'''output
+0 0.6948983669281006
+100 0.6931558847427368
+200 0.6931535005569458
+300 0.6931513547897339
+400 0.6931493282318115
+500 0.6931473016738892
+600 0.6931453943252563
+700 0.6931434869766235
+800 0.6931416988372803
+900 0.6931397914886475
+1000 0.6931380033493042
+...
+9700 0.00016829342348501086
+9800 0.00016415018762927502
+9900 0.00016021561168599874
+10000 0.0001565046259202063
+'''
+```
+
+2개의 레이어를 쌓았을 때(0.0012345188297331333)보다 loss가 더 낮아진 것을 확인할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-05-13-backpropagation.markdown b/_posts/2022-05-13-backpropagation.markdown
new file mode 100644
index 00000000000..e4c263a4bb2
--- /dev/null
+++ b/_posts/2022-05-13-backpropagation.markdown
@@ -0,0 +1,54 @@
+---
+title: "Backpropagation"
+author: Kwon
+date: 2022-05-13T00:00:00 +0900
+categories: [background]
+tags: [backpropagation]
+math: true
+mermaid: false
+---
+
+***
+
+## Backpropagation
+
+데이터를 레이어의 노드들을 통과시키면서 설정된 weight에 따라 예측 결과값을 계산하는 것을 **forward pass**라고 한다.
+
+![Forward Pass](/posting_imgs/forward.png)
+
+MLP의 결과값을 만들어 주는 필수적인 과정이지만 이것만으로는 weight를 개선하면서 학습을 진행할 수가 없다.
+
+이것을 가능하게 해준 것이 바로 backpropagation(오차 역전파)이다.
+
+역전파 알고리즘은 chain rule을 통해 각 노드들에 prediction과 target의 total error를 전달하여 $\nabla W$를 계산할 수 있게 해 준다.
+오차 역전파라는 이름이 붙은 것도 이 때문이다.
+
+이렇게 계산한 $\nabla W$를 사용하여 다음과 같이 weight를 개선한다.
+
+\\[W:=W-\alpha\nabla W\\]
+
+자세한 내용은 [관련 포스팅](/posts//dlZeroToAll-PyTorch-3/)을 참고하자
+
+위에서 나왔던 네트워크의 일부분을 떼서 역전파가 어떻게 적용되는지 확인해 보자.
+
+![Backpropagation 과정](/posting_imgs/backward.png)
+
+먼저 최종 output에 가장 가까운 $\nabla W_3$부터 계산한다.
+
+\\[\nabla w_3=\frac{\partial cost}{\partial W_3}=\frac{\partial cost}{\partial o_1}\frac{\partial o_1}{\partial y_1}\frac{\partial y_1}{\partial W_3}\\]
+
+$\nabla W_3$는 chain rule을 통해 위와 같이 미분이 바로 되는 형식으로 표현할 수 있다. 한 번 더 거슬러 올라가 보자.
+
+이번에는 $\nabla W_1$과 $\nabla W_2$를 구할 차례이다. 먼저 $\nabla X_1$을 구해보자.
+
+\\[\frac{\partial cost}{\partial W_1}=\frac{\partial cost}{\partial y_1}\frac{\partial y_1}{\partial h_{z_2}}\frac{\partial h_{z_2}}{\partial z_2}\frac{\partial z_2}{\partial W_1}\\]
+
+마찬가지로 chain rule을 통해 계산한다. $\frac{\partial cost}{\partial y_1}$은 $\nabla X_3$을 구할 때 구했었기 때문에 모든 편미분이 계산 가능하다.
+
+$\nabla W_2$는 여기서  $W_1$을 $W_2로 바꿔주기만 하면 된다.$
+
+\\[\frac{\partial cost}{\partial W_2}=\frac{\partial cost}{\partial y_1}\frac{\partial y_1}{\partial h_{z_2}}\frac{\partial h_{z_2}}{\partial z_2}\frac{\partial z_2}{\partial W_2}\\]
+
+최종 output이 없어도 forward 도중에 계산할 수 있는 편미분들은 forward pass를 하면서 미리 계산하여 저장해 두고 사용한다.
+
+이번 예제에서는 아주 간단한 네트워크에 대해 다뤘지만 더 깊고 넓은 네트워크에 대해서도 똑같이 적용할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-05-14-dlZeroToAll-PyTorch-9-1.markdown b/_posts/2022-05-14-dlZeroToAll-PyTorch-9-1.markdown
new file mode 100644
index 00000000000..a8546f869f4
--- /dev/null
+++ b/_posts/2022-05-14-dlZeroToAll-PyTorch-9-1.markdown
@@ -0,0 +1,189 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab9-1:ReLU"
+author: Kwon
+date: 2022-05-14T00:00:00 +0900
+categories: [pytorch, study]
+tags: [relu, activation, optimizer, gradient-vanishing]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab9-1: ReLU 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Problem of Sigmoid
+
+시그모이드 함수의 문제는 [backpropagation](/posts/backpropagation/)과정에서 발생한다.
+backpropagation을 수행할 때 activation의 미분값 곱해가면서 사용하게 되는데 이때 기울기가 소실되는 **gradient vanishing**문제가 발생한다. 다음 그림은 시그모이드 함수와 그 미분 함수의 그래프이다.
+
+![시그모이드 함수의 미분](/posting_imgs/lab9-1-1.png)
+
+$x$ 값이 0에서 멀어질수록 미분값이 0에 수렴하는 것을 확인할 수 있다. 한두번의 곱으로 0이 되지는 않을지라도 여러번 반복하면서 수행하게 되면 곱이 여러번 중첩되어 0으로 수렴하게 될 것이다.
+
+그렇게 되면 정상적인 학습이 불가능하다. 이런 시그모이드의 단점을 해결하기 위해 나온 것이 **ReLU**이다.
+
+***
+
+## ReLU
+
+ReLU의 식과 모습은 다음과 같이 간단히 주어진다.
+
+\\[f(x)=max(0,x)\\]]
+
+![ReLU activation](/posting_imgs/lab9-1-2.png)
+
+이렇게 activation을 구성할 경우 0 이상의 값들에 대해서는 미분값이 1이 나와 기울기 소실을 막을 수 있다.
+
+PyTorch는 이런 activation들을 `torch.nn.ReLU` 등으로 불러 사용할 수 있으며 많이 사용하는 것들은 아래와 같다.
+
+```python
+torch.nn.ReLU
+torch.nn.LeakyReLU
+torch.nn.Sigmoid
+torch.nn.Tanh
+```
+
+***
+
+## Optimizer
+
+이번 강의에서는 여러 optimizer에 대해서도 소개를 했는데, `torch.optim`으로 사용할 수 있는 optimizer로는 우리가 계속 사용한 SGD 말고도 다음과 같이 많이 존재한다.
+
+```python
+torch.optim.SGD
+torch.optim.Adadelta
+torch.optim.Adagrad
+torch.optim.Adam
+torch.optim.SparseAdam
+torch.optim.Adamax
+torch.optim.ASGD
+torch.optim.LBFGS
+torch.optim.RMSprop
+torch.optim.Rprop
+```
+
+optimizer에 대해서는 추후에 한번 자세히 공부해 보고 따로 포스팅 하려고 한다.
+
+***
+
+## Train
+
+[Lab7-2](/posts/dlZeroToAll-PyTorch-7-2/)에서 했던 mnist 학습을 adam optimizer로 한 번 학습해보고, 다중 레이어에 ReLU를 적용해서 또 한번 학습해 보겠다.
+
+### Adam
+
+데이터나 모델을 정의하는 것은 모두 이전과 동일하기 때문에 달라진 부분에 초점을 맞춰 코드를 한 번 보도록 하자.
+
+```python
+criterion = torch.nn.CrossEntropyLoss().to(device)
+optimizer = torch.optim.Adam(linear.parameters(), lr=learning_rate) # Adam optimizer
+
+total_batch = len(data_loader)
+for epoch in range(training_epochs):
+    avg_cost = 0
+
+    for X, Y in data_loader:
+        # reshape input image into [batch_size by 784]
+        # label is not one-hot encoded
+        X = X.view(-1, 28 * 28).to(device)
+        Y = Y.to(device)
+
+        optimizer.zero_grad()
+        hypothesis = linear(X)
+        cost = criterion(hypothesis, Y)
+        cost.backward()
+        optimizer.step()
+
+        avg_cost += cost / total_batch
+
+    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
+
+print('Learning finished')
+
+'''output
+Epoch: 0001 cost = 4.848181248
+Epoch: 0002 cost = 1.464641452
+Epoch: 0003 cost = 0.977406502
+Epoch: 0004 cost = 0.790303528
+Epoch: 0005 cost = 0.686833322
+Epoch: 0006 cost = 0.618483305
+Epoch: 0007 cost = 0.568978667
+Epoch: 0008 cost = 0.531290889
+Epoch: 0009 cost = 0.501056492
+Epoch: 0010 cost = 0.476258427
+Epoch: 0011 cost = 0.455025405
+Epoch: 0012 cost = 0.437031567
+Epoch: 0013 cost = 0.421489984
+Epoch: 0014 cost = 0.408599794
+Epoch: 0015 cost = 0.396514893
+Learning finished
+'''
+```
+
+달라진 점은 `optimizer`를 정의할 때 `torch.optim.Adam`을 사용하였다는 것 뿐이다.
+
+### MLP with ReLU
+
+```python
+# nn layers
+linear1 = torch.nn.Linear(784, 256, bias=True)
+linear2 = torch.nn.Linear(256, 256, bias=True)
+linear3 = torch.nn.Linear(256, 10, bias=True)
+relu = torch.nn.ReLU()
+
+# Initialization
+torch.nn.init.normal_(linear1.weight)
+torch.nn.init.normal_(linear2.weight)
+torch.nn.init.normal_(linear3.weight)
+
+# model
+model = torch.nn.Sequential(linear1, relu, linear2, relu, linear3).to(device)
+```
+
+여기서 달라진 것은 다중 레이어를 쌓고, 활성화 함수로 ReLU를 사용하여 모델을 구성했다는 것이다.
+
+학습 결과는 다음과 같다.
+
+```python
+total_batch = len(data_loader)
+for epoch in range(training_epochs):
+    avg_cost = 0
+
+    for X, Y in data_loader:
+        # reshape input image into [batch_size by 784]
+        # label is not one-hot encoded
+        X = X.view(-1, 28 * 28).to(device)
+        Y = Y.to(device)
+
+        optimizer.zero_grad()
+        hypothesis = model(X)
+        cost = criterion(hypothesis, Y)
+        cost.backward()
+        optimizer.step()
+
+        avg_cost += cost / total_batch
+
+    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
+
+print('Learning finished')
+
+'''output
+Epoch: 0001 cost = 129.325607300
+Epoch: 0002 cost = 36.169139862
+Epoch: 0003 cost = 23.025590897
+Epoch: 0004 cost = 16.021036148
+Epoch: 0005 cost = 11.609578133
+Epoch: 0006 cost = 8.560424805
+Epoch: 0007 cost = 6.369730949
+Epoch: 0008 cost = 4.782918930
+Epoch: 0009 cost = 3.604729652
+Epoch: 0010 cost = 2.682321310
+Epoch: 0011 cost = 2.086567640
+Epoch: 0012 cost = 1.640438557
+Epoch: 0013 cost = 1.297079921
+Epoch: 0014 cost = 1.083126664
+Epoch: 0015 cost = 0.751341939
+Learning finished
+'''
+```
\ No newline at end of file
diff --git a/_posts/2022-05-14-dlZeroToAll-PyTorch-9-2.markdown b/_posts/2022-05-14-dlZeroToAll-PyTorch-9-2.markdown
new file mode 100644
index 00000000000..13363e3f2be
--- /dev/null
+++ b/_posts/2022-05-14-dlZeroToAll-PyTorch-9-2.markdown
@@ -0,0 +1,139 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab9-2:Weight Initialization"
+author: Kwon
+date: 2022-05-14T01:00:00 +0900
+categories: [pytorch, study]
+tags: [weight-init, rbm, dbn, xavier, he-init]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab9-2:Weight Initialization 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Weight Initialization
+
+초기 weight의 설정은 크게 중요하지 않아 보이지만 실제로는 큰 영향을 미친다.
+
+![초기 설정에 따른 error의 차이](/posting_imgs/lab9-2-1.png)
+
+위 그래프에서도 볼 수 있듯이 적절한 초기화 기법으로 초기화를 해준 경우(N이 붙어있는 곡선) 실제로 오차가 줄어든 것을 확인할 수 있다.
+
+***
+
+## DBN(Deep Belief Network)
+
+### RBM(Restricted Boltzmann Machine)
+
+DBN을 알기 전에 먼저 RBM을 알고 가야 한다.
+
+![](/posting_imgs/lab9-2-2.png" description="RBM의 구조" %}
+
+RBM은 레이어 안에서는 연결이 없는(restricted) 레이어들의 전연결 구조이다. 일종의 encode(위쪽 방향으로 진행), decode(아래쪽 방향으로 진행)를 수행한다고 볼 수도 있다.
+
+### DBN
+
+DBN은 RBM을 통해 적절한 weight를 찾아 초기화한다.
+
+![DBN의 구조](/posting_imgs/lab9-2-3.png)
+
+위와 같이 각 레이어마다 RBM을 구성하여 다음 레이어로 한 번 갔다가 다시 돌아와 봐서 잘 복원이 되는 weight를 찾아 그것으로 초기화하여 학습에 사용한다.
+이전의 포스트에서 알아봤던 [Stacking Autoencoder](/posts/autoencoders-3/)도 이 DBN의 한 종류이다.
+
+하지만 요즘은 거의 사용하지 않는 방법이다.
+
+***
+
+## Xavier / He Initialization
+
+이 두가지 방법이 현재 많이 사용되는 방법인데, 이 방식들은 DBN과 같이 복잡한 학습들이 필요하지 않다는 것이다.
+
+단순히 분포에 따라 아래 공식을 적용하여 in/out의 node 수를 통해 계산한 값을 이용하여 초기화한다.
+
+![](/posting_imgs/lab9-2-4.png)
+
+```python
+def xavier_uniform_(tensor, gain=1):
+    fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)
+    std = gain * math.sqrt(2.0 / (fan_in + fan_out))
+    a = math.sqrt(3.0) * std # Calculate uniform bounds from standard deviation
+    with torch.no_grad():
+        return tensor.uniform_(-a, a)
+ ```
+
+ 실제 xavier의 구현을 보면 위와 같이 공식 그대로 계산하여 return해 주는 것을 볼 수 있다.
+
+***
+
+## Train with Xavier
+
+Xavier를 통해 앞서 학습해봤던 MLP를 학습하려면 다음 부분만 변경해 주면 된다.
+
+```python
+# nn layers
+linear1 = torch.nn.Linear(784, 256, bias=True)
+linear2 = torch.nn.Linear(256, 256, bias=True)
+linear3 = torch.nn.Linear(256, 10, bias=True)
+relu = torch.nn.ReLU()
+
+# xavier initialization
+torch.nn.init.xavier_uniform_(linear1.weight) # not torch.nn.init.normal_()
+torch.nn.init.xavier_uniform_(linear2.weight)
+torch.nn.init.xavier_uniform_(linear3.weight)
+
+'''output
+Parameter containing:
+tensor([[-0.0215, -0.0894,  0.0598,  ...,  0.0200,  0.0203,  0.1212],
+        [ 0.0078,  0.1378,  0.0920,  ...,  0.0975,  0.1458, -0.0302],
+        [ 0.1270, -0.1296,  0.1049,  ...,  0.0124,  0.1173, -0.0901],
+        ...,
+        [ 0.0661, -0.1025,  0.1437,  ...,  0.0784,  0.0977, -0.0396],
+        [ 0.0430, -0.1274, -0.0134,  ..., -0.0582,  0.1201,  0.1479],
+        [-0.1433,  0.0200, -0.0568,  ...,  0.0787,  0.0428, -0.0036]],
+       requires_grad=True)
+'''
+```
+
+`torch.nn.init.normal_()`대신 `torch.nn.init.xavier_uniform_()`을 사용하여 초기화를 진행한다.
+
+### Deep
+
+더 깊은 네트워크도 마찬가지로 레이어마다 `torch.nn.init.xavier_uniform_()`을 사용해 주면 된다.
+
+```python
+# nn layers
+linear1 = torch.nn.Linear(784, 512, bias=True)
+linear2 = torch.nn.Linear(512, 512, bias=True)
+linear3 = torch.nn.Linear(512, 512, bias=True)
+linear4 = torch.nn.Linear(512, 512, bias=True)
+linear5 = torch.nn.Linear(512, 10, bias=True)
+relu = torch.nn.ReLU()
+
+# xavier initialization
+torch.nn.init.xavier_uniform_(linear1.weight)
+torch.nn.init.xavier_uniform_(linear2.weight)
+torch.nn.init.xavier_uniform_(linear3.weight)
+torch.nn.init.xavier_uniform_(linear4.weight)
+torch.nn.init.xavier_uniform_(linear5.weight)
+
+'''output
+Parameter containing:
+tensor([[-0.0565,  0.0423, -0.0155,  ...,  0.1012,  0.0459, -0.0191],
+        [ 0.0772,  0.0452, -0.0638,  ...,  0.0476, -0.0638,  0.0528],
+        [ 0.0311, -0.1023, -0.0701,  ...,  0.0412, -0.1004,  0.0738],
+        ...,
+        [ 0.0334,  0.0187, -0.1021,  ...,  0.0280, -0.0583, -0.1018],
+        [-0.0506, -0.0939, -0.0467,  ..., -0.0554, -0.0325,  0.0640],
+        [-0.0183, -0.0123,  0.1025,  ..., -0.0214,  0.0220, -0.0741]],
+       requires_grad=True)
+'''
+```
+
+***
+
+#### Image Source
+
+* RBM: [https://en.wikipedia.org/wiki/File:Restricted-boltzmann-machine.svg](https://en.wikipedia.org/wiki/File:Restricted-boltzmann-machine.svg)
+
+* DBN: [http://www.dmi.usherb.ca/~larocheh/publications/deep-nets-icml-07.pdf](http://www.dmi.usherb.ca/~larocheh/publications/deep-nets-icml-07.pdf)
\ No newline at end of file
diff --git a/_posts/2022-05-15-dlZeroToAll-PyTorch-9-3.markdown b/_posts/2022-05-15-dlZeroToAll-PyTorch-9-3.markdown
new file mode 100644
index 00000000000..9632df16270
--- /dev/null
+++ b/_posts/2022-05-15-dlZeroToAll-PyTorch-9-3.markdown
@@ -0,0 +1,156 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab9-3:Dropout"
+author: Kwon
+date: 2022-05-15T00:00:00 +0900
+categories: [pytorch, study]
+tags: [dropout, overfitting]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab9-3: Dropout 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Dropout
+
+[lab7-1](/posts/dlZeroToAll-PyTorch-7-1/)에서 알아본 것처럼 학습을 하다보면 train set에 너무 과적합(overfitting)되는 경우가 발생한다.
+
+이때 언급한 과적합을 덜어주기 위한 방법에는 다음과 같은 것들이 있었다.
+
+* Early Stoping: valid set의 loss가 줄어들지 않을 때 학습을 중지한다.
+* Reducing Network Size
+* Weight Decay: weight가 너무 커지지 않도록 wight가 커질수록 함께 커지는 penalty를 부여한다.
+* Dropout: node의 일부를 꺼서 학습하는 node를 줄인다.
+* Batch Normalization: 학습 중에 배치 단위로 정규화 하는 것
+
+오늘은 이 중에서 dropout에 대해 알아보려 한다.
+
+dropout은 일정 확률에 따라 레이어의 node를 끄면서 학습을 진행하는 것을 말한다.
+즉, 레이어의 일부 node를 학습에 사용하지 않는 것이다.
+
+![Dropout이 적용된 네트워크(우)](/posting_imgs/lab9-3-1.png)
+
+위 그림처럼 각 노드들은 일정한 확률로 비활성화 한다. 이런 식으로 학습을 하게 되면 과하게 학습되는 것을 막아 과적합 모델이 만들어지는 것을 막을 수 있을 뿐만 아니라.
+각 시행마다 확률적으로 꺼지고 켜지는 node가 달라지기 때문에 다양한 네트워크로 학습하여 앙상블한 효과도 얻을 수 있어 성능의 향상으로도 이루어질 수 있다고 한다.
+
+***
+
+## Train with MNIST
+
+학습하는 코드는 모델의 구성할 때 dropout이 추가된 것 말고는 큰 변화가 없지만 주의해야 할 점이 있다. 먼저 코드를 보자
+
+```python
+# nn layers
+linear1 = torch.nn.Linear(784, 512, bias=True)
+linear2 = torch.nn.Linear(512, 512, bias=True)
+linear3 = torch.nn.Linear(512, 512, bias=True)
+linear4 = torch.nn.Linear(512, 512, bias=True)
+linear5 = torch.nn.Linear(512, 10, bias=True)
+relu = torch.nn.ReLU()
+dropout = torch.nn.Dropout(p=drop_prob)
+
+# xavier initialization
+torch.nn.init.xavier_uniform_(linear1.weight)
+torch.nn.init.xavier_uniform_(linear2.weight)
+torch.nn.init.xavier_uniform_(linear3.weight)
+torch.nn.init.xavier_uniform_(linear4.weight)
+torch.nn.init.xavier_uniform_(linear5.weight)
+
+# model
+model = torch.nn.Sequential(linear1, relu, dropout,
+                            linear2, relu, dropout,
+                            linear3, relu, dropout,
+                            linear4, relu, dropout,
+                            linear5).to(device)
+```
+
+여기까지는 `Sequential`통해 모델을 구성할 때 dropout을 추가해 준 것 말고는 다른 것이 없지만 아래를 보면 학습하기 전에 `model.train()`이라는 새로운 코드가 추가된 것을 볼 수 있다.
+
+```python
+total_batch = len(data_loader)
+model.train()    # set the model to train mode (dropout=True)
+for epoch in range(training_epochs):
+    avg_cost = 0
+
+    for X, Y in data_loader:
+        # reshape input image into [batch_size by 784]
+        # label is not one-hot encoded
+        X = X.view(-1, 28 * 28).to(device)
+        Y = Y.to(device)
+
+        optimizer.zero_grad()
+        hypothesis = model(X)
+        cost = criterion(hypothesis, Y)
+        cost.backward()
+        optimizer.step()
+
+        avg_cost += cost / total_batch
+
+    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
+
+print('Learning finished')
+
+'''output
+Epoch: 0001 cost = 0.308392197
+Epoch: 0002 cost = 0.142623395
+Epoch: 0003 cost = 0.113427199
+Epoch: 0004 cost = 0.093490042
+Epoch: 0005 cost = 0.083772294
+Epoch: 0006 cost = 0.077040948
+Epoch: 0007 cost = 0.067025252
+Epoch: 0008 cost = 0.063156039
+Epoch: 0009 cost = 0.058766391
+Epoch: 0010 cost = 0.055902217
+Epoch: 0011 cost = 0.052059878
+Epoch: 0012 cost = 0.048243146
+Epoch: 0013 cost = 0.047231019
+Epoch: 0014 cost = 0.045120358
+Epoch: 0015 cost = 0.040942233
+Learning finished
+'''
+```
+
+이건 model을 train 용으로 사용할 것인지, eval 용으로 사용할 것인지에 따라 mode를 변경시켜주는 코드이다. (이후에 나올 batch normalization 등에서도 사용)
+
+이렇게 모드를 나눠 주는 이유는 학습할 때와 달리 검증할 때는 dropout을 사용하지 않고 모든 node를 사용해서 예측을 진행하기 때문이다.
+
+그러므로 검증할 때는 다음과 같이 코드를 작성해야 한다.
+
+```python
+# Test model and check accuracy
+with torch.no_grad():
+    model.eval()    # set the model to evaluation mode (dropout=False)
+
+    # Test the model using test sets
+    X_test = mnist_test.test_data.view(-1, 28 * 28).float().to(device)
+    Y_test = mnist_test.test_labels.to(device)
+
+    prediction = model(X_test)
+    correct_prediction = torch.argmax(prediction, 1) == Y_test
+    accuracy = correct_prediction.float().mean()
+    print('Accuracy:', accuracy.item())
+
+    # Get one and predict
+    r = random.randint(0, len(mnist_test) - 1)
+    X_single_data = mnist_test.test_data[r:r + 1].view(-1, 28 * 28).float().to(device)
+    Y_single_data = mnist_test.test_labels[r:r + 1].to(device)
+
+    print('Label: ', Y_single_data.item())
+    single_prediction = model(X_single_data)
+    print('Prediction: ', torch.argmax(single_prediction, 1).item())
+
+'''output
+Accuracy: 0.9820999503135681
+Label:  8
+Prediction:  8
+'''
+```
+
+다른 부분은 모두 동일하게 작성하고 `model.eval()`만 추가하여 model을 검증하기 위한 mode로 바꿔주는 것을 볼 수 있다.
+
+***
+
+#### Image Source
+
+* Dropout: [http://jmlr.org/papers/volume15/srivastava14a.old/srivastava14a.pdf](http://jmlr.org/papers/volume15/srivastava14a.old/srivastava14a.pdf)
\ No newline at end of file
diff --git a/_posts/2022-05-15-dlZeroToAll-PyTorch-9-4.markdown b/_posts/2022-05-15-dlZeroToAll-PyTorch-9-4.markdown
new file mode 100644
index 00000000000..306a1d0a7cc
--- /dev/null
+++ b/_posts/2022-05-15-dlZeroToAll-PyTorch-9-4.markdown
@@ -0,0 +1,119 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab9-4:Batch Normalization"
+author: Kwon
+date: 2022-05-15T01:00:00 +0900
+categories: [pytorch, study]
+tags: [batch-normalization, gradient-vanishing, gradient-exploding, internal-covariate-shift]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab9-4: Batch Normalization 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Gradient Vanishing / Gradient Exploding
+
+Gradient Vanishing(기울기 소실)과 Gradient Exploding(기울기 폭주)는 정상적인 학습을 할 수 없게 만드는 요인들이다.
+
+기울기 소실은 [앞서](/posts/dlZeroToAll-PyTorch-9-1/) 살펴본 것처럼 역전파를 수행할 때 작은 미분값을 chain rule에 따라 계속 곱하다가 결국 0으로 소멸해버리는 것이었다.
+
+반대로 기울기 폭주는 너무 큰 미분값을 계속 곱하다가 수렴하지 못하고 발산해버리는 것을 의미한다.
+
+이들을 방지하기 위해 시도해볼 수 있는 것은 아래와 같은 방법들이 있다
+
+* Change activation function
+* Careful initialization
+* Small learning rate
+* Batch Normalization
+
+이 중에서 이번 강의에서는 Batch Normalization에 대한 내용을 다루었다.
+
+***
+
+Batch normalization을 제시할 때 주장했던 기울기 소실과 폭주에 대한 주된 이유가 **Internal Covariate Shift**였는데 이에 대해 한번 알아보자.
+
+## Covariate Shift
+
+먼저 Covariate Shift는 공변량 변화라고도 하는데 입력 데이터의 분포가 학습할 때와 테스트할 때 다르게 나타나는 현상을 말한다.
+
+예를 들어 손글씨를 분류하는 모델을 만드려고 할 때 학습 데이터로 한글 손글씨를 사용해서 학습한 후 영어 손글씨를 분류하려고 하면 당연히 분류가 제대로 되지 않을 것이다.
+
+이는 모델이 학습한 분포와 테스트 데이터의 분포가 다르기 때문이다.
+
+## Internal Covariate Shift
+
+이런 Covariate Shift가 네트워크 내부에서 발생하는 것이 Inteanal Covariate Shift이다.
+
+이전까지는 모델 단위의 분포 문제라고 생각하고 첫 입력에만 normalization을 했지만, 실제로는 아래와 같이 스탭마다 레이어 단위로 Covariate Shift가 발생한다는 것이다.
+
+![Internal Covariate Shift](/posting_imgs/lab9-4-1.png)
+
+그러므로 각 레이어 학습마다 각 minibatch를 normalization을 해야 하며 이를 Batch normalization이라고 한다.
+
+***
+
+## Batch Normalization
+
+Batch normalization은 다음과 같은 알고리즘으로 진행된다.
+
+![Batch Normalization Algorithm](/posting_imgs/lab9-4-2.png)
+
+$\mu_\mathcal{B}$와 $\sigma^2_\mathcal{B}$는 minibatch를 통해 게산된 평균과 분산이며 sample mean/variance라고도 불린다. 이들을 이용해서 normalize 하게 되는데 이때 $\epsilon$은 0으로 나누는 것을 방지하는 아주 작은 값이다.
+
+이렇게 normalize된 데이터를 가지고 $\gamma$와 $\beta$를 학습하면 Batch normalization을 통한 학습이 한 번 끝나게 된다.
+
+### Evaluation
+
+검증할 때 Batch normalization을 사용하는 모델이 값의 일부가 바뀐 batch를 받는다면 그 batch의 $\mu_\mathcal{B}$와 $\sigma^2_\mathcal{B}$ 역시 바뀌게 된다.
+이렇게 되면 $\hat{x}$도 다르게 계산되는데 이럴 경우 같은 값이라도 batch의 일부분이 바뀌었다는 사실 하나만으로 다른 결과가 나오게 된다.
+
+검증 과정에서 이러한 일일 발생하는 것을 막기 위해 학습 시에 게산했던 $\mu_\mathcal{B}$와 $\sigma^2_\mathcal{B}$를 따로 저장해 두고, test할 때는 이미 계산된 $\mu_\mathcal{B}$와 $\sigma^2_\mathcal{B}$를 사용한다.
+
+이런 방식으로 결과값을 도출하면 같은 값에 같은 결과를 얻을 수 있다. 이런 이유로 Batch normalization도 [dropout](/posts/dlZeroToAll-PyTorch-9-3/)과 같이 따로 eval mode로 바꿔줘야 한다.
+
+***
+
+## Train
+
+Batch normalization을 적용하려면 기존 코드에서 `torch.nn.BatchNorm1d`를 추가하여 model을 구성하면 된다. 위치는 activation 직전에 사용하는 것이 일반적이라고 한다.
+
+```python
+# nn layers
+linear1 = torch.nn.Linear(784, 32, bias=True)
+linear2 = torch.nn.Linear(32, 32, bias=True)
+linear3 = torch.nn.Linear(32, 10, bias=True)
+relu = torch.nn.ReLU()
+bn1 = torch.nn.BatchNorm1d(32)
+bn2 = torch.nn.BatchNorm1d(32)
+
+nn_linear1 = torch.nn.Linear(784, 32, bias=True)
+nn_linear2 = torch.nn.Linear(32, 32, bias=True)
+nn_linear3 = torch.nn.Linear(32, 10, bias=True)
+
+# model with Batch normalization
+bn_model = torch.nn.Sequential(linear1, bn1, relu,
+                            linear2, bn2, relu,
+                            linear3).to(device)
+
+# model without Batch normalization
+nn_model = torch.nn.Sequential(nn_linear1, relu,
+                               nn_linear2, relu,
+                               nn_linear3).to(device)
+
+# define cost/loss & optimizer
+criterion = torch.nn.CrossEntropyLoss().to(device)    # Softmax is internally computed.
+bn_optimizer = torch.optim.Adam(bn_model.parameters(), lr=learning_rate)
+nn_optimizer = torch.optim.Adam(nn_model.parameters(), lr=learning_rate)
+```
+
+model은 위에서 말한 것처럼 이와같이 구현할 수 있고, 학습은 dropout과 동일하게 `model.train()`을 먼저 해 주고 진행하면 된다.
+
+![](/posting_imgs/lab9-4-3.png)
+
+실제로 Batch normalization을 적용한 경우가 더 학습이 잘 된것을 확인할 수 있다.
+
+***
+
+#### Image Source
+
+* Batch Normalization: [https://arxiv.org/pdf/1502.03167.pdf](https://arxiv.org/pdf/1502.03167.pdf)
\ No newline at end of file
diff --git a/_posts/2022-05-22-dlZeroToAll-PyTorch-10-1.markdown b/_posts/2022-05-22-dlZeroToAll-PyTorch-10-1.markdown
new file mode 100644
index 00000000000..a07702dc668
--- /dev/null
+++ b/_posts/2022-05-22-dlZeroToAll-PyTorch-10-1.markdown
@@ -0,0 +1,228 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab10-1: Convolution, Lab10-2: MNIST CNN"
+author: Kwon
+date: 2022-05-22T00:00:00 +0900
+categories: [pytorch, study]
+tags: [convolution, padding, pooling, cnn]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab10-1: Convolution, Lab10-2: MNIST CNN 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Convolution
+
+강의 자료에서는 **'이미지(2차원 매트릭스) 위에서 stride 만큼 filter(kernel)을 이동시키면서 겹쳐지는 부분의 각 원소의 값을 곱해서 더한 값을 출력으로 하는 연산'**이라고 나와있다. 자세히 어떤 과정의 연산인지 확인해 보자.
+
+아래와 같이 차례대로 input, filter, output 행렬이 있다고 해보자.
+
+![](/posting_imgs/lab10-1-1.png)
+
+input, filter의 진한 부분을 각 자리끼리 곱해서 더해주는 것으로 output의 진한 부분의 결과를 낸다. 이 예제의 stride는 1이기 때문에 한 칸씩 커널을 이동하면서 이 과정을 진행하여 최종적으로 새로운 3x3 output을 만들어낸다.
+
+우리가 원하는 filter와 stride를 설정하여 위 과정을 통해 새로운 매트릭스를 만드는 것이 **convolution**이다. 
+
+### Padding
+
+Convolution 연산에 쓰이는 데이터에 **padding**이라는 처리를 할 수 있는데, 이것은 input를 일정한 수로 감싼다는 뜻으로 1의 zero-padding을 한다는 것은 다음과 같은 입력으로 연산을 진행하겠다는 뜻이다.
+
+![](/posting_imgs/lab10-1-2.png){: width="40%"}
+
+### Output Size
+
+Convolution output의 크기는 다음과 같이 주어진다.
+
+\\[ Output \, size = \frac{input \, size - filter \, size + (2*padding)}{Stride} + 1 \\]
+
+예를 들어 input size = (32, 64), kernel = 5, stride = 1, padding = 0로 주어졌을 때 
+
+\\[ (\frac{(32-5)+(0\times2)}{1}+1 , \frac{(32-5)+(0\times2)}{1}+1) = (28, 60) \\]
+
+위처럼 계산할 수 있다.
+
+### Input Type in PyTorch
+
+PyTorch에서 `torch.nn.Conv2d`을 이용하여 convolution을 연산할 때 input data의 type은 `torch.Tensor`, shape은 (N x C x H x W) = (batch_size, channel, height, width)으로 맞춰줘야 한다.
+
+위에서 size를 게산했던 예제를 실제로 코드로 실행하여 확인하려면 다음과 같이 작성하면 된다.
+
+![](/posting_imgs/lab10-1-3.png){: width="40%"}
+
+실제로도 계산 결과와 같은 shape이 나오는 것을 확인할 수 있다.
+
+### Convolution and Perceptron
+
+convolution을 다음과 같이 perceptron으로 나타낼 수도 있다.
+
+![](/posting_imgs/lab10-1-4.png)
+
+filter의 값을 weight로 가지고 있는 perceptron에 stride만큼 움직이면서 매트릭스를 통과시키면 output의 각 자리 결과값들이 계산된다.
+
+***
+
+## Pooling
+
+Pooling은 주어진 kernel size만큼의 구역을 대표하는 값들을 찾아서 그 대표값으로 새로운 매트릭스를 구성하는 것을 말한다.
+
+![](/posting_imgs/lab10-1-5.png)
+
+위 그림은 kernel size가 2인 max pooling과 average pooling을 나타낸 것이다.
+
+max pooling은 그 구역의 최대값을 선택하는 것이고, average pooling은 평균값을 선택하여 새로운 매트릭스를 만드는 것이다.
+
+***
+
+## Train CNN with MNIST
+
+### Import and Data
+
+seed를 고정하고 mnist dataset을 불러와서 `DataLoader`를 적용하여 minibatch로 학습할 수 있도록 만들어 준다.
+
+```python
+import torch
+import torchvision.datasets as dsets
+import torchvision.transforms as transforms
+import torch.nn.init
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+# for reproducibility
+torch.manual_seed(777)
+if device == 'cuda':
+    torch.cuda.manual_seed_all(777)
+
+learning_rate = 0.001
+training_epochs = 15
+batch_size = 100
+
+# MNIST dataset
+mnist_train = dsets.MNIST(root='MNIST_data/',
+                          train=True,
+                          transform=transforms.ToTensor(),
+                          download=True)
+
+mnist_test = dsets.MNIST(root='MNIST_data/',
+                         train=False,
+                         transform=transforms.ToTensor(),
+                         download=True)
+
+# dataset loader
+data_loader = torch.utils.data.DataLoader(dataset=mnist_train,
+                                          batch_size=batch_size,
+                                          shuffle=True,
+                                          drop_last=True)
+```
+
+### Model and Loss/Optimizer
+
+이전과 다르게 3개의 큰 layer로 나누어 model을 생성한다. 2개의 convolution layer를 통과하고 하나의 fully connected layer를 통과시킨다.
+단, fully connected layer로 들어가기 전에 linear layer에 들어갈 수 있도록 data를 `view`를 이용하여 flat하게 만든다.
+
+```python
+class CNN(torch.nn.Module):
+
+    def __init__(self):
+        super(CNN, self).__init__()
+        # L1 ImgIn shape=(?, 1, 28, 28)
+        #    Conv     -> (?, 32, 28, 28)
+        #    Pool     -> (?, 32, 14, 14)
+        self.layer1 = torch.nn.Sequential(
+            torch.nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.MaxPool2d(kernel_size=2, stride=2))
+        # L2 ImgIn shape=(?, 32, 14, 14)
+        #    Conv      ->(?, 64, 14, 14)
+        #    Pool      ->(?, 64, 7, 7)
+        self.layer2 = torch.nn.Sequential(
+            torch.nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
+            torch.nn.ReLU(),
+            torch.nn.MaxPool2d(kernel_size=2, stride=2))
+        # Final FC 7x7x64 inputs -> 10 outputs
+        self.fc = torch.nn.Linear(7 * 7 * 64, 10, bias=True)
+        torch.nn.init.xavier_uniform_(self.fc.weight)
+
+    def forward(self, x):
+        out = self.layer1(x)
+        out = self.layer2(out)
+        out = out.view(out.size(0), -1)   # Flatten them for FC
+        out = self.fc(out)
+        return out
+
+model = CNN().to(device)
+```
+
+loss는 cross entropy를 사용하고 optimizer는 Adam을 사용한다. loss를 `to(device)`로 학습에 사용할 device에 붙여주고, optimizer를 생성할 때 `model.parameters()`를 넣어주는 것을 잊지 말자
+
+```python
+criterion = torch.nn.CrossEntropyLoss().to(device)
+optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+```
+
+### Train
+
+기존에 minibatch로 학습하던 코드와 크게 다를 것이 없다.
+
+```python
+# train my model
+total_batch = len(data_loader)
+print('Learning started. It takes sometime.')
+for epoch in range(training_epochs):
+    avg_cost = 0
+
+    for X, Y in data_loader:
+        # image is already size of (28x28), no reshape
+        # label is not one-hot encoded
+        X = X.to(device)
+        Y = Y.to(device)
+
+        optimizer.zero_grad()
+        hypothesis = model(X)
+        cost = criterion(hypothesis, Y)
+        cost.backward()
+        optimizer.step()
+
+        avg_cost += cost / total_batch
+
+    print('[Epoch: {:>4}] cost = {:>.9}'.format(epoch + 1, avg_cost))
+
+print('Learning Finished!')
+
+'''output
+Learning started. It takes sometime.
+[Epoch:    1] cost = 0.223892078
+[Epoch:    2] cost = 0.0621332489
+[Epoch:    3] cost = 0.0448851325
+[Epoch:    4] cost = 0.0356322788
+[Epoch:    5] cost = 0.0289768185
+[Epoch:    6] cost = 0.0248806253
+[Epoch:    7] cost = 0.0209558196
+[Epoch:    8] cost = 0.0180539284
+[Epoch:    9] cost = 0.0153525099
+[Epoch:   10] cost = 0.0128902728
+[Epoch:   11] cost = 0.0104844831
+[Epoch:   12] cost = 0.0100922994
+[Epoch:   13] cost = 0.00803675782
+[Epoch:   14] cost = 0.00732926652
+[Epoch:   15] cost = 0.00600952888
+Learning Finished!
+'''
+```
+
+convolution layer를 이용하여 model을 구성해도 학습이 잘 된 것을 확인할 수 있다.
+
+```python
+# Test model and check accuracy
+with torch.no_grad():
+    X_test = mnist_test.test_data.view(len(mnist_test), 1, 28, 28).float().to(device)
+    Y_test = mnist_test.test_labels.to(device)
+
+    prediction = model(X_test)
+    correct_prediction = torch.argmax(prediction, 1) == Y_test
+    accuracy = correct_prediction.float().mean()
+    print('Accuracy:', accuracy.item())
+    
+'''output
+Accuracy: 0.9878999590873718
+'''
+```
\ No newline at end of file
diff --git a/_posts/2022-05-23-dlZeroToAll-PyTorch-10-3.markdown b/_posts/2022-05-23-dlZeroToAll-PyTorch-10-3.markdown
new file mode 100644
index 00000000000..3e1b960510e
--- /dev/null
+++ b/_posts/2022-05-23-dlZeroToAll-PyTorch-10-3.markdown
@@ -0,0 +1,217 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab10-3: Visdom"
+author: Kwon
+date: 2022-05-23T00:00:00 +0900
+categories: [pytorch, study]
+tags: [visdom, visualization]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab10-3: Visdom 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Visdom
+
+Visdom은 Meta 사(facebook)에서 제공하는 PyTorch에서 사용할 수 있는 시각화 도구이다. 실시간으로 데이터를 시각화하면서 바뀌는 점을 확인할 수 있다는 장점이 있다.
+
+### Install
+
+터미널에서 pip를 이용하여 설치할 수 있다. 설치가 완료된 후에는 visdom server를 실행해 주어야 사용이 가능하다.
+
+```python
+> pip isntall visdom
+> python -m visdom.server
+# You can navigate to http://localhost:PORT
+```
+
+서버를 실행한 후에 나오는 localhost 주소를 통해 visdom 화면을 확인할 수 있다.
+
+#### AttributeError
+
+필자의 경우 `AttributeError: module 'brotli' has no attribute 'error'`라는 에러가 발생해서 아래 코드를 통해 `brotli` module을 추가서 설치하여 해결하였다.
+
+```python
+conda install -c conda-forge brotlipy
+```
+
+### Text
+
+먼저 설치에 문제가 없는지 확인하는 겸 간단한 text를 출력해보자. `vis.text()`사용하여 출력할 수 있다.
+
+```python
+vis.text("Hello, world!",env="main")
+```
+
+![](/posting_imgs/lab10-3-1.png)
+
+위와같이 새로운 창에 Hello, world가 출력되는 것을 확인할 수 있다.
+
+### Image
+
+이번에는 이미지를 출력해보자
+
+무작위 픽셀로 생성한 200x200 이미지와 3개의 28x28 이미지를 만들고 출력해보면 다음과 같다. 이 때는 하나의 이미지는 `vis.image()`를, 여러 이미지는 `vis.images()`를 사용한다.
+
+```python
+a=torch.randn(3,200,200)
+vis.image(a)
+vis.images(torch.Tensor(3,3,28,28))
+```
+
+![](/posting_imgs/lab10-3-2.png)
+
+다음은 조금 더 이미지 다운 데이터인 mnist와 CIFAR10를 출력하려 한다.
+
+```python
+MNIST = dsets.MNIST(root="./MNIST_data",train = True,transform=torchvision.transforms.ToTensor(), download=True)
+cifar10 = dsets.CIFAR10(root="./cifar10",train = True, transform=torchvision.transforms.ToTensor(),download=True)
+
+#CIFAR10
+data = cifar10.__getitem__(0)
+print(data[0].shape)
+vis.images(data[0],env="main")
+
+# MNIST
+data = MNIST.__getitem__(0)
+print(data[0].shape)
+vis.images(data[0],env="main")
+```
+
+![](/posting_imgs/lab10-3-3.png)
+
+두꺼비(?)와 숫자 5가 잘 나온다. 또한 이런 이미지들도 당연히 `vis.images()`를 통해 한번에 많은 이미지도 출력할 수 있다.
+
+```py
+data_loader = torch.utils.data.DataLoader(dataset = MNIST,
+                                          batch_size = 32,
+                                          shuffle = False)
+for num, value in enumerate(data_loader):
+    value = value[0]
+    print(value.shape)
+    vis.images(value)
+    break
+```
+
+![](/posting_imgs/lab10-3-4.png)
+
+굳이 for문을 쓰지 않고도 다음과 같이 iter 객체를 사용하여 출력할 수도 있다.
+
+```py
+img = next(iter(data_loader))[0]
+vis.images(img)
+```
+
+지금까지 띄운 창들을 모두 끄고싶으면 다음 코드를 실행해서 끌 수 있다.
+
+```py
+vis.close(env="main")
+```
+
+이렇게 하면 main에 띄워진 것들을 모두 끌 수 있다.
+
+### Line Plot
+
+Lint Plot은 `vis.line()`에 X, Y 데이터를 넣어 선형 그래프를 그릴 수 있다.
+
+```py
+Y_data = torch.randn(5)
+plt = vis.line (Y=Y_data)
+
+X_data = torch.Tensor([1,2,3,4,5])
+plt = vis.line(Y=Y_data, X=X_data)
+```
+
+![](/posting_imgs/lab10-3-5.png)
+
+가장 간단한 예제로 Y 데이터만 설정해 준 것인데, 이 경우에 X축은 무조건 0과 1 사이를 나눠 point를 생성한다.
+만약 X 값들을 다르게 만들어주고 싶으면 새로운 tensor를 만들어 넣어주면 된다.
+
+기존의 plot에 point를 추가할 수도 있다. `vis.line()`에 새로 넣을 데이터와 그 데이터를 추가할 plot을 넣어주고, `update='append'`로 설정한다.
+
+```py
+Y_append = torch.randn(1)
+X_append = torch.Tensor([6])
+
+vis.line(Y=Y_append, X=X_append, win=plt, update='append')
+```
+![](/posting_imgs/lab10-3-6.png)
+
+두개의 다른 그래프를 비교하기 위해 겹쳐 그리고 싶으면 (n, 2) shape의 데이터와 그에 맞는 X 데이터를 넣어주면 된다.
+
+```py
+num = torch.Tensor(list(range(0,10)))
+num = num.view(-1,1)
+num = torch.cat((num,num),dim=1)
+
+plt = vis.line(Y=torch.randn(10,2), X = num)
+```
+
+![](/posting_imgs/lab10-3-7.png)
+
+X는 0-9이 2줄 저장되어있는 데이터, Y는 (10,2)의 랜덤 데이터이다.
+
+그래프에 대한 범례는 `showlegend=True`로 보이게 할 수 있고, `legend = []`를 통해 직접 지정해 줄 수 있다. defualt는 그낭 정수로 나온다.
+
+```py
+plt = vis.line(Y=Y_data, X=X_data, opts = dict(title='Test', showlegend=True))
+plt = vis.line(Y=Y_data, X=X_data, opts = dict(title='Test', legend = ['1번'],showlegend=True))
+plt = vis.line(Y=torch.randn(10,2), X = num, opts=dict(title='Test', legend=['1번','2번'],showlegend=True))
+```
+
+![](/posting_imgs/lab10-3-8.png)
+
+<br>
+
+마지막으로, 가장 재밌게 봤던 기능인데 아까 나온 append 기능을 통해 실행이 반복될 때마다 plot을 자동으로 업데이트하도록 코드를 작성할 수 있다.
+
+```py
+def loss_tracker(loss_plot, loss_value, num):
+    '''num, loss_value, are Tensor'''
+    vis.line(X=num,
+             Y=loss_value,
+             win = loss_plot,
+             update='append'
+             )
+
+plt = vis.line(Y=torch.Tensor(1).zero_())
+
+for i in range(500):
+    loss = torch.randn(1) + i
+    loss_tracker(plt, loss, torch.Tensor([i]))
+```
+
+![](/posting_imgs/lab10-3-9.gif)
+
+실제로 학습할 때 loss를 넣어 학습을 모니터링하는데 유용하게 쓸 수 있다.
+
+[이전 포스팅](/posts/dlZeroToAll-PyTorch-10-3/)에서 학습할 때 사용했던 코드에서 `loss_tracker`를 추가하여 실행하면 다음과 같이 모니터링이 가능하다.
+
+```py
+total_batch = len(data_loader)
+
+for epoch in range(training_epochs):
+    avg_cost = 0
+    
+    for X, Y in data_loader:
+        X = X.to(device)
+        Y = Y.to(device)
+        
+        optimizer.zero_grad()
+        hypothesis = model(X)
+        
+        cost = criterion(hypothesis, Y)
+        cost.backward()
+        optimizer.step()
+        
+        avg_cost += cost / total_batch
+    
+    print('[Epoch:{}] cost = {}'.format(epoch+1, avg_cost))
+    # tracking
+    loss_tracker(loss_plt, torch.Tensor([avg_cost]), torch.Tensor([epoch]))
+print('Learning Finished!')
+```
+
+![](/posting_imgs/lab10-3-10.gif)
+
+loss가 어떻게 변하고 있는지 확인하는데 매우 적합한 기능인것 같다.
\ No newline at end of file
diff --git a/_posts/2022-05-23-dlZeroToAll-PyTorch-10-4.markdown b/_posts/2022-05-23-dlZeroToAll-PyTorch-10-4.markdown
new file mode 100644
index 00000000000..ddc35a6f2c6
--- /dev/null
+++ b/_posts/2022-05-23-dlZeroToAll-PyTorch-10-4.markdown
@@ -0,0 +1,258 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab10-4: ImageFolder"
+author: Kwon
+date: 2022-05-23T01:00:00 +0900
+categories: [pytorch, study]
+tags: [imagefolder, cnn, transform]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab10-4: ImageFolder 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## ImageFolder
+
+`torchvision.datasets`에 있는 ImageFolder는 directory에 따라 category를 자동으로 labeling 하여 데이터로 만들어 준다. 우리가 찍은 사진을 학습하는데 사용할 때 아주 좋은 기능이다.
+
+이번 강의에서는 미리 찍어서 제공해 준 회색, 빨간색 의자 사진 분류를 해볼 것이다.
+
+먼저 category에 맞게 directory를 생성해주어야 ImageFolder를 사용할 수 있으므로, directory는 다음과 같은 구조여야 한다.
+
+![](/posting_imgs/lab10-4-1.png)
+
+```py
+import torchvision
+from torchvision import transforms
+
+from torch.utils.data import DataLoader
+
+from matplotlib.pyplot import imshow
+%matplotlib inline
+
+trans = transforms.Compose([
+    transforms.Resize((64,128))
+])
+
+train_data = torchvision.datasets.ImageFolder(root='custom_data/origin_data', transform=trans)
+```
+
+원본 데이터가 있는 곳을 root로 잡고 `Compose`를 통해 적용할 `transforms`들을 묶어 넣어준다. 원본 데이터가 265x512로 너무 커서 64x128로 바꾸어주는 과정을 거친다.
+여기서는 하나의 `transforms`을 사용하지만 어러개를 사용해야할 때 `Compose`로 묶어 사용할 수 있다.
+
+이렇게 불러온 데이터들을 정리하여 train data로 만들어준다. directory 상 gray가 더 빠르므로 label 0, red가 label 1이다.
+
+```py
+for num, value in enumerate(train_data):
+    data, label = value
+    print(num, data, label)
+    
+    if(label == 0):
+        data.save('custom_data/train_data/gray/%d_%d.jpeg'%(num, label))
+    else:
+        data.save('custom_data/train_data/red/%d_%d.jpeg'%(num, label))
+```
+
+***
+
+## Train
+
+### Imports and Data
+
+```py
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+import torch.optim as optim
+from torch.utils.data import DataLoader
+
+import torchvision
+import torchvision.transforms as transforms
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+torch.manual_seed(777)
+if device =='cuda':
+    torch.cuda.manual_seed_all(777)
+
+trans = transforms.Compose([
+    transforms.ToTensor()
+])
+
+train_data = torchvision.datasets.ImageFolder(root='./custom_data/train_data', transform=trans)
+data_loader = DataLoader(dataset = train_data, batch_size = 8, shuffle = True, num_workers=2)
+```
+
+앞서 만들어놓은 train data를 `ImageFolder`로 불러와서 사용한다. 물론 자동으로 label을 붙여 데이터를 생성해준다.
+
+### Model and Loss/Optimizer
+
+두 번의 CNN layer를 거치고 FC layer를 하나 통과시키는 [lab10-2](/posts/dlZeroToAll-PyTorch-10-3/)에서 사용한 것과 data shape말고는 거의 같은 모델이다.
+
+```py
+class CNN(nn.Module):
+    def __init__(self):
+        super(CNN, self).__init__()
+        self.layer1 = nn.Sequential(
+            nn.Conv2d(3,6,5),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        self.layer2 = nn.Sequential(
+            nn.Conv2d(6,16,5),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        self.layer3 = nn.Sequential(
+            nn.Linear(16*13*29, 120),
+            nn.ReLU(),
+            nn.Linear(120,2)
+        )
+        
+    def forward(self, x):
+        out = self.layer1(x)
+        out = self.layer2(out)
+        out = out.view(out.shape[0], -1)
+        out = self.layer3(out)
+        return out
+```
+
+이렇게 만든 model은 꼭 테스트 하는 과정을 거쳐야 한다고 한다. 테스트는 넣으려는 데이터와 shape이 같은 Tensor를 생성하여 통과시켜보는 것을 말한다.
+
+```py
+#testing 
+net = CNN().to(device)
+test_input = (torch.Tensor(3,3,64,128)).to(device)
+test_out = net(test_input)
+```
+
+optimizer와 loss도 역시 동일하다.
+
+```py
+optimizer = optim.Adam(net.parameters(), lr=0.00005)
+loss_func = nn.CrossEntropyLoss().to(device)
+```
+
+### Train model
+
+학습 역시 이전과 다르지 않개 진행한다.
+
+```py
+total_batch = len(data_loader)
+
+epochs = 7
+for epoch in range(epochs):
+    avg_cost = 0.0
+    for num, data in enumerate(data_loader):
+        imgs, labels = data
+        imgs = imgs.to(device)
+        labels = labels.to(device)
+        optimizer.zero_grad()
+        out = net(imgs)
+        loss = loss_func(out, labels)
+        loss.backward()
+        optimizer.step()
+        
+        avg_cost += loss / total_batch
+        
+    print('[Epoch:{}] cost = {}'.format(epoch+1, avg_cost))
+print('Learning Finished!')
+
+'''output
+[Epoch:1] cost = 0.6341210007667542
+[Epoch:2] cost = 0.3761218190193176
+[Epoch:3] cost = 0.1116236224770546
+[Epoch:4] cost = 0.03525366261601448
+[Epoch:5] cost = 0.016341226175427437
+[Epoch:6] cost = 0.009176642633974552
+[Epoch:7] cost = 0.005688846111297607
+Learning Finished!
+'''
+```
+
+### Save model
+
+이렇게 학습한 모델을 매번 다시 학습하는 것은 너무 비효율적이다. 그래서 모델을 저장해 준다.
+
+```py
+torch.save(net.state_dict(), "./model/model.pth")
+```
+
+불러오는 것은 다음과 같이 새로운 CNN 객체를 생성하여 넣어주면 된다.
+
+```py
+new_net = CNN().to(device)
+new_net.load_state_dict(torch.load('./model/model.pth'))
+```
+
+기존의 모델과 동일한 것을 확인할 수 있다.
+
+```py
+print(net.layer1[0])
+print(new_net.layer1[0])
+
+print(net.layer1[0].weight[0][0][0])
+print(new_net.layer1[0].weight[0][0][0])
+
+net.layer1[0].weight[0] == new_net.layer1[0].weight[0]
+
+'''output
+Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
+Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
+tensor([-0.0914,  0.0032, -0.0170, -0.0211,  0.0933], device='cuda:0',
+       grad_fn=<SelectBackward>)
+tensor([-0.0914,  0.0032, -0.0170, -0.0211,  0.0933], device='cuda:0',
+       grad_fn=<SelectBackward>)
+tensor([[[True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True]],
+
+        [[True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True]],
+
+        [[True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True],
+         [True, True, True, True, True]]], device='cuda:0')
+'''
+```
+
+### Test
+
+test할 때도 train data와 똑같이 처리하여 사용하면 된다.
+
+```py
+trans=torchvision.transforms.Compose([
+    transforms.Resize((64,128)),
+    transforms.ToTensor()
+])
+test_data = torchvision.datasets.ImageFolder(root='./custom_data/test_data', transform=trans)
+
+test_set = DataLoader(dataset = test_data, batch_size = len(test_data))
+```
+
+이렇게 하면 역시 label이 붙은 채로 data가 생성되게 된다.
+
+test 결과는 다음과 같다.
+
+```py
+with torch.no_grad():
+    for num, data in enumerate(test_set):
+        imgs, label = data
+        imgs = imgs.to(device)
+        label = label.to(device)
+        
+        prediction = net(imgs)
+        
+        correct_prediction = torch.argmax(prediction, 1) == label
+        
+        accuracy = correct_prediction.float().mean()
+        print('Accuracy:', accuracy.item())
+```
\ No newline at end of file
diff --git a/_posts/2022-05-26-dlZeroToAll-PyTorch-10-5.markdown b/_posts/2022-05-26-dlZeroToAll-PyTorch-10-5.markdown
new file mode 100644
index 00000000000..da2fe9851f2
--- /dev/null
+++ b/_posts/2022-05-26-dlZeroToAll-PyTorch-10-5.markdown
@@ -0,0 +1,456 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab10-5: VGG"
+author: Kwon
+date: 2022-05-26T00:00:00 +0900
+categories: [pytorch, study]
+tags: [cnn, vgg]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab10-5: Advence CNN(VGG) 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## VGG-net(Visual Geometry Group-network)
+
+VGG-net(이하 VGG)은 14년도 ILSVRC(Imagenet 이미지 인식 대회)에 나온 네트워크로 옥스포드의 Visual Geometry Group에서 만든 모델이다.
+
+먼저 논문에서 발표한 VGG모델들의 구조를 보자.
+
+![](/posting_imgs/lab10-5-1.png)
+
+총 6개의 구조를 만들어 성능을 비교하였는데 E로 갈 수록 깊은 모델이며 모델이 깊어질수록 좋은 성능을 보였다고 한다.
+
+VGG는 여러 층에 따라 이름을 붙여주는데 예를 들면 E의 경우 총 19층(16(conv) + 3(fc) = 19)이므로 VGG19이다.
+
+### VGG16 Architecture
+
+뒤의 학습에서도 사용할 VGG16의 구조를 대표적으로 확인해보자. Imagenet의 이미지 크기인 224x224에 rgb 3채널의 input을 받는 모델의 구조이다.
+
+구조를 보면 3x3 커널로 여러번의 conv를 진행하는데 그 이유는 훈련해야할 가중치를 줄이기 위해서이다.
+
+224x224 크기의 행렬에 3x3커널로 stride=1 의 conv를 2번 하면 output size는 220x220이고,
+
+\\[ Output \, size = \frac{input \, size - filter \, size + (2*padding)}{Stride} + 1 \\\\\\
+=((224 - 3) + 1)-3 + 1 = 220
+ \\]
+
+5x5 커널로 stride=1 의 conv를 하면 output size는 $224-5+1=220$로 output size가 같은 것을 볼 수 있다. 참고로 3번의 3x3 conv를 하면 7x7 conv 한번과 size가 같다.
+
+같은 output size지만 3x3 conv를 사용한 경우에는 학습해야할 가중치는 $2(3\times3)=18$이고, 5x5의 경우에는 $5\times5=25$로 학습해야할 양이 더 많다. 또한 여러개의 conv 층을 사용할 경우 비선형성이 더 늘어나서 보다 복잡한 데이터를 잘 학습할 수 있다는 장점도 있다.
+
+또 다른 VGG의 특징으로는 conv마다 padding=1을 해줘서 conv 전후의 size를 같게 만들어준다는 것이다. 이런 특성들을 확인하고 VGG16의 구조를 살펴보자.
+
+![VGG16 Architecture](/posting_imgs/lab10-5-2.png)
+
+앞서 언급했듯이 3x3 conv를 padding=1로 2~3번 적용하고 max plooing(kernel size=2, stride=2)을 하여 크기를 줄여 다음 conv로 넘겨준다. (이때 activation은 ReLU)
+
+이렇게 conv + max pooling의 큰 layer를 5번 통과하고 나면 data를 platten하게 만들어서 fully connected layer를 통과시킨다.
+이때 fully connected layer는 마지막 max pooling의 output size에 맞춰 $7\times7\times512$ 의 input을 받을 수 있게 한다. 마지막 layer에서는 imagenet의 class 개수인 1000으로 맞춰주고 softmax를 적용시킨다.
+
+이를 코드로 풀어 표현하면 다음과 같다.
+
+```py
+conv2d = nn.Conv2d(3, 64, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(3, 64, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+
+nn.MaxPool2d(kernel_size=2, stride=2)
+
+conv2d = nn.Conv2d(64, 128, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(128, 128, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+
+nn.MaxPool2d(kernel_size-2, stride=2)
+
+conv2d = nn.Conv2d(128, 256, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(256, 256, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(256, 256, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+
+nn.MaxPool2d(kernel_size=2, stride=2)
+
+conv2d = nn.Conv2d(256, 512, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(512, 512, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(512, 512, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+
+nn.MaxPool2d(kernel_size=2, stride=2)
+
+conv2d = nn.Conv2d(512, 512, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(512, 512, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+conv2d = nn.Conv2d(512, 512, kernel_size=3, padding=1)
+nn.ReLU(inplace=True)
+
+nn.MaxPool2d(kernel_size=2, stride=2)
+
+x = x.view(x.size(0), -1) # flatten
+
+nn.Linear(512 * 7 * 7, 4096),
+nn.ReLU(True),
+nn.Dropout(),
+nn.Linear(4096, 4096),
+nn.ReLU(True),
+nn.Dropout(),
+nn.Linear(4096, 1000),
+```
+
+***
+
+## Code with VGG
+
+PyTorch에 구현된 VGG를 한번 뜯어보자. 먼저 conv layer를 만드는 과정이다.
+
+```py
+cfg = {
+    'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], #8(conv) + 3(fc) =11 == vgg11
+    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], # 10 + 3 = vgg 13
+    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'], #13 + 3 = vgg 16
+    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'], # 16 +3 =vgg 19
+    'custom' : [64,64,64,'M',128,128,128,'M',256,256,256,'M']
+}
+
+def make_layers(cfg, batch_norm=False):
+    layers = []
+    in_channels = 3
+    
+    for v in cfg:
+        if v == 'M':
+            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
+            
+            if batch_norm:
+                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
+            else:
+                layers += [conv2d, nn.ReLU(inplace=True)]
+            in_channels = v
+    return nn.Sequential(*layers)
+```
+
+`cfg`로 정의된 dictionary에서 모델을 골라 넣어주면 된다. 우리가 만들고 싶은 것은 VGG16이니까 `cfg['D']`를 `make_layers`에 넣어주면 함수가 지정한 모델 코드(D)의 list에 따라 `nn.Sequential`로 묶인 모델을 반환해준다.
+
+conv layer 부분을 모두 만들었으니 이제 fc layer를 이어서 VGG를 완성하면 된다.
+
+```py
+class VGG(nn.Module):
+    def __init__(self, features, num_classes=1000, init_weights=True):
+        super(VGG, self).__init__()
+        
+        self.features = features #convolution
+        
+        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
+        
+        self.classifier = nn.Sequential(
+            nn.Linear(512 * 7 * 7, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, num_classes),
+        )#FC layer
+        
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x) #Convolution 
+        x = self.avgpool(x) # avgpool
+        x = x.view(x.size(0), -1) #flatten
+        x = self.classifier(x) #FC layer
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+```
+
+앞서 만들었던 CNN은 `features`에 전달되고 7x7로 바꿔주기 위한 pooling layer와 고정적으로 사용되는 linear layer를 정의해준다.
+
+이때 모델들의 가중치 초기화는 `_initialize_weights`에 의해 이루어지는데 conv layer는 `kaiming_normal_`을 사용해서, batch norm layer는 weight를 1로 bias를 0으로, linear layer는 normal distribution에 bais는 0으로 초기화한다.
+
+`forward`에서는 각 layer를 통과시키면서 학습을 한다. 다만 linear layer로 들어가기 전에 `view`를 통해 flat하게 만들어주는 과정이 추가되어야 한다.
+
+***
+
+## Train
+
+VGG를 통한 학습도 한번 해보자.
+
+### Import and Setting
+
+```py
+import torch
+import torch.nn as nn
+
+import torch.optim as optim
+
+import torchvision
+import torchvision.transforms as transforms
+
+import visdom
+
+vis = visdom.Visdom()
+vis.close(env="main")
+
+def loss_tracker(loss_plot, loss_value, num):
+    '''num, loss_value, are Tensor'''
+    vis.line(X=num,
+             Y=loss_value,
+             win = loss_plot,
+             update='append'
+             )
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+torch.manual_seed(777)
+if device =='cuda':
+    torch.cuda.manual_seed_all(777)
+```
+
+저번에 다뤘었던 [visdom](/posts/dlZeroToAll-PyTorch-10-3/)을 이용하여 시각화를 하면서 학습을 진행한다.
+
+### Data
+
+데이터는 CIFAR10를 이용하여 학습을 진행한다.
+
+```py
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+trainset = torchvision.datasets.CIFAR10(root='./cifar10', train=True,
+                                        download=True, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=512,
+                                          shuffle=True, num_workers=0)
+
+testset = torchvision.datasets.CIFAR10(root='./cifar10', train=False,
+                                       download=True, transform=transform)
+
+testloader = torch.utils.data.DataLoader(testset, batch_size=4,
+                                         shuffle=False, num_workers=0)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+```
+
+데이터셋들을 불러 `DataLoader`를 통해 학습하기 용이하게 만들어준다.
+
+```py
+import matplotlib.pyplot as plt
+import numpy as np
+
+# get some random training images
+dataiter = iter(trainloader)
+images, labels = dataiter.next()
+vis.images(images/2 + 0.5)
+
+# print labels
+print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+'''output
+truck   dog horse truck
+'''
+```
+
+![](/posting_imgs/lab10-5-3.png)
+
+class와 이미지가 잘 받아진 것을 확인할 수 있다.
+
+### Model
+
+```py
+import torchvision.models.vgg as vgg
+
+cfg = [32,32,'M', 64,64,128,128,128,'M',256,256,256,512,512,512,'M'] #13 + 3 =vgg16
+
+class VGG(nn.Module):
+
+    def __init__(self, features, num_classes=1000, init_weights=True):
+        super(VGG, self).__init__()
+        self.features = features
+        #self.avgpool = nn.AdaptiveAvgPool2d((7, 7))    -> 굳이 쓸 필요가 없음
+        self.classifier = nn.Sequential(
+            nn.Linear(512 * 4 * 4, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, num_classes),
+        )
+        if init_weights:
+            self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        #x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.constant_(m.bias, 0)
+
+vgg16= VGG(vgg.make_layers(cfg),10,True).to(device)
+```
+
+앞서 정의했던 VGG16은 `'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M']`의 형태였는데 위의 모델은 조금 달라보인다.
+이건 CIFAR10의 이미지가 32x32로 imgagenet의 것보다 작기 때문이다. 기존대로 pooling을 모두 진행하면 데이터의 크기가 너무 작아지므로 그것을 방지하기 위함이다.
+
+같은 이유로 `avgpool` layer도 빠졌는데 기존의 max pooling만 해도 이미 7x7보다 크기가 작기 때문이다.
+
+나머지는 모두 같은 방식으로 작성되었다.
+
+```py
+a=torch.Tensor(1,3,32,32).to(device)
+out = vgg16(a)
+print(out)
+
+'''output
+tensor([[ 0.0125, -0.0020, -0.0270,  0.0210,  0.0100,  0.0126, -0.0009,  0.0242,
+         -0.0099,  0.0185]], device='cuda:0', grad_fn=<AddmmBackward>)
+'''
+```
+
+test했을 때도 문제가 없으므로 사용할 준비가 모두 되었다.
+
+### Optimizer and Loss
+
+```py
+criterion = nn.CrossEntropyLoss().to(device)
+optimizer = torch.optim.SGD(vgg16.parameters(), lr = 0.005,momentum=0.9)
+
+# 학습이 진행됨에 따라 lr 조절
+lr_sche = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9) # optimizer의 step이 5번 진행될 때마다 gamma만큼 곱함
+```
+
+기존과 다른 점은 학습된 정도에 따라 learning rate를 줄이는 코드가 추가되었다는 것이다.
+
+### Train
+
+```py
+print(len(trainloader))
+epochs = 50
+
+for epoch in range(epochs):  # loop over the dataset multiple times
+    running_loss = 0.0
+    lr_sche.step()
+    for i, data in enumerate(trainloader, 0):
+        # get the inputs
+        inputs, labels = data
+        inputs = inputs.to(device)
+        labels = labels.to(device)
+
+        # zero the parameter gradients
+        optimizer.zero_grad()
+
+        # forward + backward + optimize
+        outputs = vgg16(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        # print statistics
+        running_loss += loss.item()
+        if i % 30 == 29:    # print every 30 mini-batches
+            loss_tracker(loss_plt, torch.Tensor([running_loss/30]), torch.Tensor([i + epoch*len(trainloader) ]))
+            print('[%d, %5d] loss: %.3f' %
+                  (epoch + 1, i + 1, running_loss / 30))
+            running_loss = 0.0
+        
+
+print('Finished Training')
+
+'''output
+98
+[1,    30] loss: 2.302
+[1,    60] loss: 2.299
+[1,    90] loss: 2.284
+[2,    30] loss: 2.208
+[2,    60] loss: 2.128
+[2,    90] loss: 2.068
+[3,    30] loss: 1.974
+[3,    60] loss: 1.856
+[3,    90] loss: 1.793
+[4,    30] loss: 1.727
+[4,    60] loss: 1.678
+[4,    90] loss: 1.626
+[5,    30] loss: 1.571
+[5,    60] loss: 1.529
+[5,    90] loss: 1.513
+[6,    30] loss: 1.487
+[6,    60] loss: 1.452
+[6,    90] loss: 1.429
+[7,    30] loss: 1.387
+[7,    60] loss: 1.363
+[7,    90] loss: 1.333
+[8,    30] loss: 1.314
+[8,    60] loss: 1.284
+[8,    90] loss: 1.248
+...
+[50,    30] loss: 0.034
+[50,    60] loss: 0.030
+[50,    90] loss: 0.030
+Finished Training
+'''
+```
+
+![](/posting_imgs/lab10-5-4.png)
+
+`lr_sche.step()`이 추가된 것 말고 크게 다른 점은 없다.
+
+### Test
+
+```py
+correct = 0
+total = 0
+
+with torch.no_grad():
+    for data in testloader:
+        images, labels = data
+        images = images.to(device)
+        labels = labels.to(device)
+        outputs = vgg16(images)
+        
+        _, predicted = torch.max(outputs.data, 1)
+        
+        total += labels.size(0)
+        
+        correct += (predicted == labels).sum().item()
+
+print('Accuracy of the network on the 10000 test images: %d %%' % (
+    100 * correct / total))
+
+Accuracy of the network on the 10000 test images: 75 %
+```
+
+정확도는 75%로 나왔다.
\ No newline at end of file
diff --git a/_posts/2022-05-27-dlZeroToAll-PyTorch-10-6.markdown b/_posts/2022-05-27-dlZeroToAll-PyTorch-10-6.markdown
new file mode 100644
index 00000000000..d87bb0f1b5c
--- /dev/null
+++ b/_posts/2022-05-27-dlZeroToAll-PyTorch-10-6.markdown
@@ -0,0 +1,520 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab10-6: ResNet"
+author: Kwon
+date: 2022-05-27T00:00:00 +0900
+categories: [pytorch, study]
+tags: [cnn, resnet, skip-connection]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab10-6: Advence CNN(ResNet) 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Plain Network
+
+Plain network는 skip connection을 사용하지 않은 일반적인 CNN 신경망을 의미한다.
+이러한 plain net이 깊어지면 깊어질수록 backpropagation을 할 때 기울기 소실이나 폭발이 발생할 확률이 높아진다.
+
+![20-layer vs. 56-layer plain network](/posting_imgs/lab10-6-1.png)
+
+위 그래프에서도 확인할 수 있듯이 plain network를 깊게 쌓은 것이 오히려 학습이 잘 안 된 것을 볼 수 있다.
+이는 너무 깊은 plain network에서 기울기 소실 혹은 폭발이 발생하여 원래 원하던 방향으로 학습이 안되었기 때문이다.
+
+***
+
+## Identity Mapping
+
+Classification problem에서 모델이 완벽하게 학습하였다면 input($x$)과 output(y)의 의미는 같아야 한다. (강아지 이미지면 강아지 categry)
+이 말은 $H(x)$가 $x$가 되도록 학습하면 된다는 것이다. 즉, $H(x)=x$가 되도록 학습을 한다는 것이며 이는 일종의 **항등함수(identity function)**이므로,
+Classification problem의 model을 최적화 한다는 것은 identity mapping을 학습하는 것과 같아진다.
+
+***
+
+## ResNet
+
+ResNet은 skip connection을 적용한 network로 기울기 소실을 해결하면서 layer를 더 깊게 쌓아 성능이 좋은 모델을 구성할 수 있다.
+
+### Skip(Shortcut) Connection
+
+기존의 network에서는 input ($x$)를 target ($y$)로 mapping(identity mapping)하는 $H(x)$를 얻는 것이 목적이었다.
+하지만 identity mapping을 통해 학습을 진행해도 layer가 쌓일수록 기울기 소실이 발생하는 것은 어쩔 수 없다.
+
+이를 해결하기위해 제안한 방법론이 Residual learning이다. 이는 $H(x)$를 직접 학습하는 것이 아닌 **잔차(residual)**, $F(x) = H(x)-x$를 최소화하는 것을 목표로 하는 방법이다.
+이 잔차 $F(x)$를 최소화 하면 $H(x) = x$에 가까운 이상적인 모델을 찾을 수 있다는 발상이다.
+
+이 방법론이 제안된 전제는 **residual mapping이 그냥 identity mapping하는 방식보다 최적화하기 쉽다**이다.
+즉, 직접 $H(x)=x$를 목적으로 학습하는 것 보다는 현재 block의 input(이전 block의 output)의 정보($x$, identity)를 지닌 채 추가적으로 학습하는 것이 더 쉬운 학습이 된다는 것이다.
+
+또한, output에 $x$를 더해주게 되면 미분을 해도 $x$의 미분값은 1이기 때문에 각 layer들은 최소 1의 미분값을 지니게 되어 앞서 문제였던 기울기 소실 문제가 해결된다.
+
+이런 network를 구성하기 위해 아래의 구조와 같이 여러 layer를 건너뛰어(skip) 한 layer의 output을 다음 layer의 input에 더해주는 구조를 만들었다.
+identity가 다음 output으로 가는 지름길(shortcut)을 만들어 주었다고 해서 **shortcut connection**이라고도 한다.
+
+![Skip Connection(Residual learning)](/posting_imgs/lab10-6-2.png)
+
+이렇게 skip connection이 적용된 부분을 **residual block**이라고 한다.
+
+### Bottleneck Block
+
+Residual block애서 중간 layer를 1x1 -> 3x3 -> 1x1 의 bottleneck 구조를 만들어 demension redeuction을 통해 연산 시간을 줄인 구조이다.
+
+![](/posting_imgs/lab10-6-3.png" description="Bottleneck Block" %}
+
+ResNet 18/34에서는 일반적인 residual block을 사용하고 ResNet 50/101/152에서는 bottleneck block을 사용한다고 한다.
+
+### ResNet-34 Architecture
+
+ResNet은 아래와 같이 5개의 깊이를 가진 구조가 존재한다.
+
+![ResNet Models](/posting_imgs/lab10-6-4.png)
+
+고정된 layer들을 제외하면 크게 4개의 layer가 있는 것을 볼 수 있는데, VGG와 비슷하게 3x3 conv에 padding 1을 적용하여 하나의 큰 layer안에서는 ourput size가 고정되는 것을 볼 수 있다.
+
+![위부터 순서대로 Resnet-34, 34-layer plain, VGG-19](/posting_imgs/lab10-6-5.png)
+
+그림으로 보면 위와 같은 구조를 지니고 있다. VGG 구조보다 확실히 깊은 구조인 것을 확인할 수 있다.
+
+***
+
+## Code with ResNet
+
+PyTorch의 Resnet을 뜯어보자.
+
+### BasicBlock
+
+먼저 residual block이다.
+
+```py
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        # x.shape = 3, 64, 64
+        identity = x
+        # identity = 3, 64, 64
+        out = self.conv1(x) # 3x3 stride = stride = 2
+        out = self.bn1(out)
+        out = self.relu(out)
+        # out.shape = 3, 32, 32
+        out = self.conv2(out) # 3x3 stride = 1
+        # out.shape = 3, 32, 32
+        out = self.bn2(out)
+        # out.shape = 3, 32, 32
+        # identity = 3, 64, 64 -> 덧셈 불가
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+```
+
+앞서 살펴봤던 residual block의 구조와 다르지 않은 모습이다. 2개의 3x3 conv layer를 통과하고 마지막에 입력인 identity를 더해준 후 output을 내어주는 형태이다.
+
+다만 다른 점이 있다면 downsample이 있는 것인데, 이는 주석으로 처리된 예시로 설명이 된다. 만약 3x64x64의 입력이 들어오고 `conv1`의 stride를 2로 한다면 identity를 더하기 전의 `out.shape`이 3x32x32로 기존과 달라지게 되어 identity와의 덧셈이 불가능해진다.
+이 경우 identity를 downsample하여 shape을 맞춰준다. 그래서 만약 stride에 따라 out의 shape이 달라지게 되는 경우 downsample 옵션을 주어 shape을 맞춰야 한다.
+
+### Bottleneck
+
+```py
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = conv1x1(inplanes, planes)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = conv3x3(planes, planes, stride)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = conv1x1(planes, planes * self.expansion)
+        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x) # 1x1 stride = 1
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out) # 3x3 stride = stride 
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out) # 1x1 stride = 1
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+```
+
+3x3 / 1x1 conv를 따로 정의하여 모델에 사용하고 있는 모습이다. 이 때도 같은 이유로 downsample 옵션이 있다.
+
+### ResNet
+
+위의 block class들을 이용해 network를 구성할 차례이다. 
+
+#### _make_layer
+
+먼저 layer를 만들어주는 함수부터 보자.
+
+```py
+    # self.inplanes = 64
+    # self.layer1 = self._make_layer(block=Bottleneck, 64, layers[0]=3)
+    def _make_layer(self, block, planes, blocks, stride=1):
+        
+        downsample = None
+        
+        # identity 값을 낮춰서 shape을 맞춰주기 위함. channel도 맞춰주기.
+        if stride != 1 or self.inplanes != planes * block.expansion: # 64 != 64 * 4
+            
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride), #conv1x1(256, 512, 2) #conv1x1(64, 256, 2)
+                nn.BatchNorm2d(planes * block.expansion), #batchnrom2d(512) #batchnrom2d(256)
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        # layers.append(Bottleneck(64, 64, 1, downsample))
+        
+        self.inplanes = planes * block.expansion #self.inplanes = 128 * 4
+        
+        for _ in range(1, blocks): 
+            layers.append(block(self.inplanes, planes)) # * 3
+
+        return nn.Sequential(*layers)
+```
+
+stride가 1이 아니거나 input과 output의 shape이 맞지 않을 경우 downsample을 `conv1x1`을 이용하여 shape을 맞출 수 있게 설정해준다.
+
+다음부터는 layer의 크기에 맞게 layer를 block 개수 만큼 만들어 쌓은 후에 반환한다. 주석의 입력 에시를 통해 따라가 보면 이해에 조금 도움이 될 것 같다.
+
+### __init__
+
+```py
+    # model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) => resnet 50 
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
+        super(ResNet, self).__init__()
+        
+        self.inplanes = 64
+        
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
+        
+        # outputs = self.conv1(inputs)
+        # outputs.shape = 64, 112, 112
+        
+        self.bn1 = nn.BatchNorm2d(64)
+        self.relu = nn.ReLU(inplace=True)
+        
+        # inputs = 64, 112, 112
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        # output = 64, 56, 56
+        
+        self.layer1 = self._make_layer(block, 64, layers[0]'''3''')
+        self.layer2 = self._make_layer(block, 128, layers[1]'''4''', stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2]'''6''', stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3]'''3''', stride=2)
+        
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules(): # weight init
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+```
+
+이전에 만들었던 함수들을 모두 사용하여 network를 만든다. 먼저 고정적으로 들어갈 7x7 conv와 maxpooling layer를 만들어준다.
+
+다음으로는 `_make_layer`를 통해 입력한 layer 개수에 맞게 layer를 생성한다. 마지막으로 1x1로 average pooling을 하고 class 개수에 맞춰 fc layer를 통과시키면 모든 학습이 끝나게 된다.
+
+가중치의 초기화는 conv의 경우 `'fan_out'` mode의 `kaiming_normal_`를 사용하고, bn(batch normalize)의 경우 wieght를 1, bias를 0으로 초기화한다.
+`zero_init_residual`옵션을 주면 특정 layer의 wieght를 0으로 초기화하는데 이는 해당 논문에서 이 시행을 적용하였더니 성능이 0.2~0.3% 올랐다고 해서 들어가 있는 옵션이라고 한다.
+
+### forward
+
+```py
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+```
+
+`forward`에서는 지금까지 만들었던 모델들을 순서대로 이어서 학습되도록 한다.
+
+### ResNet Models
+
+```py
+def resnet18(pretrained=False, **kwargs):
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs) #=> 2*(2+2+2+2) +1(conv1) +1(fc)  = 16 +2 =resnet 18
+    return model
+
+def resnet50(pretrained=False, **kwargs):
+    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) #=> 3*(3+4+6+3) +(conv1) +1(fc) = 48 +2 = 50
+    return model
+
+def resnet152(pretrained=False, **kwargs):
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs) # 3*(3+8+36+3) +2 = 150+2 = resnet152    
+    return mode
+```
+
+위와 같은 방법으로 여러 resnet을 만들어 사용할 수 있다.
+
+하지만 이미 module로 다 만들어져 있기 때문에 아래와 같이 만들어진 것을 사용해서 model을 생성해도 정상적으로 생성되는 것을 확인할 수 있다.
+
+```py
+import torchvision.models.resnet as resnet
+
+res = resnet.resnet50()
+res
+
+'''ourput
+ResNet(
+  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
+  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+  (relu): ReLU(inplace=True)
+  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
+  (layer1): Sequential(
+    (0): Bottleneck(
+      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (relu): ReLU(inplace=True)
+      (downsample): Sequential(
+        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      )
+    )
+    (1): Bottleneck(
+      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+...
+    )
+  )
+  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
+  (fc): Linear(in_features=2048, out_features=1000, bias=True)
+)
+'''
+```
+
+***
+
+## Train with ResNet
+
+[VGG](/posts/dlZeroToAll-PyTorch-10-5/)를 통해 학습했을 때와 마찬가지로 CIFAR10 data를 사용하여 학습을 진행한다.
+
+### Data
+
+대부분 VGG 학습할 때와 같다. 다만 다른 부분은 실제 data의 평균과 분산을 구해서 normalize를 진행한다.
+
+```py
+transform = transforms.Compose([
+    transforms.ToTensor()
+])
+
+trainset = torchvision.datasets.CIFAR10(root='./cifar10', train=True, download=True, transform=transform)
+
+print(trainset.data.shape)
+
+# 각 축마다 구해서 normalization
+train_data_mean = trainset.data.mean( axis=(0,1,2) )
+train_data_std = trainset.data.std( axis=(0,1,2) )
+
+
+print(train_data_mean)
+print(train_data_std)
+
+train_data_mean = train_data_mean / 255
+train_data_std = train_data_std / 255
+
+print(train_data_mean)
+print(train_data_std)
+
+transform_train = transforms.Compose([
+    transforms.RandomCrop(32, padding=4),
+    transforms.ToTensor(),
+    transforms.Normalize(train_data_mean, train_data_std)
+])
+
+transform_test = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize(train_data_mean, train_data_std)
+])
+
+trainset = torchvision.datasets.CIFAR10(root='./cifar10', train=True,
+                                        download=True, transform=transform_train)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=256,
+                                          shuffle=True, num_workers=0)
+
+testset = torchvision.datasets.CIFAR10(root='./cifar10', train=False,
+                                       download=True, transform=transform_test)
+
+testloader = torch.utils.data.DataLoader(testset, batch_size=256,
+                                         shuffle=False, num_workers=0)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+```
+
+### Model
+
+이번 강의에서는 pyTorch의 ResNet을 사용하지 않고 위에서 정의한 class를 사용하여 학습을 진행했다.
+위에서 만든 class와 함수들을 resnet.py에 저장해주고 import하여 사용한다.
+
+```py
+import resnet/
+
+conv1x1=resnet.conv1x1
+Bottleneck = resnet.Bottleneck
+BasicBlock= resnet.BasicBlock
+```
+
+각 블록들을 먼저 정의해준다.
+
+```py
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
+        super(ResNet, self).__init__()
+        self.inplanes = 16
+        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1,
+                               bias=False)
+        self.bn1 = nn.BatchNorm2d(16)
+        self.relu = nn.ReLU(inplace=True)
+        #self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) => 사이즈 작아서 필요 없음
+        
+        self.layer1 = self._make_layer(block, 16, layers[0], stride=1)
+        self.layer2 = self._make_layer(block, 32, layers[1], stride=1)
+        self.layer3 = self._make_layer(block, 64, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 128, layers[3], stride=2)
+        
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(128 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        #x.shape =[1, 16, 32,32]
+        x = self.bn1(x)
+        x = self.relu(x)
+        #x = self.maxpool(x)
+
+        x = self.layer1(x)
+        #x.shape =[1, 128, 32,32]
+        x = self.layer2(x)
+        #x.shape =[1, 256, 32,32]
+        x = self.layer3(x)
+        #x.shape =[1, 512, 16,16]
+        x = self.layer4(x)
+        #x.shape =[1, 1024, 8,8]
+        
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+```
+
+정의한 블록들을 사용하여 앞서 구현했던 것과 같이 network를 구성한다.
+다만 CIFAR10의 이미지 사이즈가 imagenet보다 작기 때문에 그에 맞게 첫 conv의 kernel size를 3으로 조절해주고, pooling은 없애며,
+layer의 `inplanes`도 (64, 128, 256, 512)에서 (16, 32, 64, 128)로 바꿔준다.
+
+이후로 다른 점은 크게 없어 visdom을 통한 결과만 한 번 확인해 보면 다음과 같이 80%의 정확도까지 학습이 된 것을 확인할 수 있다.(20 epoch 진행)
+
+![Loss(좌), Accuracy(우)](/posting_imgs/lab10-6-6.png)
+
+#### Image Source
+
+* 20-layer vs. 56-layer plain network, Residual Block, ResNet Models Table, Resnet-34 Architecture: [https://arxiv.org/pdf/1512.03385.pdf](https://arxiv.org/pdf/1512.03385.pdf)
+* Bottleneck Bock: [http://icml.cc/2016/tutorials/icml2016_tutorial_deep_residual_networks_kaiminghe.pdf](http://icml.cc/2016/tutorials/icml2016_tutorial_deep_residual_networks_kaiminghe.pdf)
\ No newline at end of file
diff --git a/_posts/2022-06-04-dlZeroToAll-PyTorch-11-0.markdown b/_posts/2022-06-04-dlZeroToAll-PyTorch-11-0.markdown
new file mode 100644
index 00000000000..9b7d0aeaa82
--- /dev/null
+++ b/_posts/2022-06-04-dlZeroToAll-PyTorch-11-0.markdown
@@ -0,0 +1,58 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab11-0: RNN intro"
+author: Kwon
+date: 2022-06-04T00:00:00 +0900
+categories: [pytorch, study]
+tags: [rnn]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab11-0: RNN intro 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## RNN(Recurrent Neural Network)
+
+RNN은 sequential data를 잘 학습하기 위해 고안된 모델이다. Sequential data란 단어, 문장이나 시게열 데이터와 같이 데이터의 순서도 데이터의 일부인 데이터들을 말한다. 
+이런 데이터는 이전 순서의 데이터들을 생각하여 학습을 하는 것이 더효과적일 것이다.
+이렇게 학습하기 위해 RNN은 다음과 같은 구조로 구성되어 있다.
+
+![RNN의 구조](/posting_imgs/lab11-0-1.png)
+
+한 모델로 계속 학습하지만 이전의 output이 다음의 input과 함께 들어가는 구조이다. 이렇게 output을 다음 input으로 보낼 때 이 값을 hidden state라고 하며, 이런 식으로 모델을 구성하면 과거의 데이터를 반영하여 학습할 수 있게 된다.
+
+이때 RNN 내부의 actiavtion은 tanh나 sigmoid function을 사용한다. 지금까지 봐왔던 network들은 기울기 소실 문제 때문에 ReLU를 사용해야 성능이 더 좋아진다고 했던 것 같은데 RNN의 내부에서는 왜 사용하지 않는 걸까.
+그 이유는 RNN의 구조 때문인데, RNN은 같은 layer를 여러번 반복하여 학습하는 구조를 가진다. 이때 ReLU와 같은 activation을 사용하면 1보다 큰 수가 반복하여 곱해지기 때문에 **기울기 폭발**이 발생할 가능성이 매우 높다.
+그래서 RNN의 내부에서 만큼은 절대값이 1을 넘지 않은 tanh나 sigmoid를 사용하는 것이다.
+
+Acivation을 표현하여 조금 더 자세히 모델을 나타내면 다음과 같은 구조를 확인할 수 있다.
+
+![](/posting_imgs/lab11-0-2.png)
+
+일반화하여 수식으로 나타내면 다음과 같고
+
+\\[h_t=f(h_{t-1}, x_t)\\]
+
+activation과 weight를 명시하여 표현하면 다음과 같다.
+
+\\[h_t=tanh(W_h h_{t-1}, W_x x_t)\\]
+
+***
+
+## Usages of RNN
+
+이런 RNN의 구조를 응용하여 다음과 같은 구조들로 사용할 수 있다.
+
+![Usages of RNN](/posting_imgs/lab11-0-3.png)
+
+* **one to many**
+: 하나의 입력을 받아 여러 출력을 내는 구조이다. 하나의 이미지를 받아 그에 대한 설명을 문장(여러개의 단어)으로 출력하는 것을 에로 들 수 있다.
+
+* **many to one**
+: 여러 입력을 받아 하나의 출럭을 내는 구조이다. 문장을 입력받아 그 문장이 나타내는 감정의 label을 출력하는 것을 예로 들 수 있다.
+
+* **many to many**
+: 2가지의 구조가 있는 것을 볼 수 있다.
+  - 입력이 다 끝나는 지점부터 여러 출력을 내는 구조로, 문장을 입력받아 번역하는 모델을 예로 들 수 있다. 이 경우 문장의 중간에 번역을 진행하면 다 끝나고 나서 문장의 의미가 달라질 수 있기 때문에 먼저 입력 문장을 다 듣고 번역을 진행하게 된다.
+  - 입력 하나하나를 받으면서 그때마다 모델의 출력을 내는 구조이다. 영상을 처리할 때 frame 단위의 이미지로 나눠 입력을 받은 후 각 frame을 입력 받을 때마다 처리하는 것을 예로 들 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-06-06-dlZeroToAll-PyTorch-11-1.markdown b/_posts/2022-06-06-dlZeroToAll-PyTorch-11-1.markdown
new file mode 100644
index 00000000000..80fec07b48f
--- /dev/null
+++ b/_posts/2022-06-06-dlZeroToAll-PyTorch-11-1.markdown
@@ -0,0 +1,95 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab11-1: RNN Baisics"
+author: Kwon
+date: 2022-06-06T00:00:00 +0900
+categories: [pytorch, study]
+tags: [rnn]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab11-1: RNN Baisics 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## with PyTorch
+
+PyTorch에서 RNN은 in/output size만 잘 맞춰주면 바로 사용이 가능하다.
+**"h, e, l, o"** 4개의 알파벳으로 이루어진 데이터셋을 통해 2차원의 output(class가 2개)을 내는 RNN을 만들어볼 것이다.
+
+```py
+import torch
+import numpy as np
+
+torch.manual_seed(0)
+
+input_size = 4
+hidden_size = 2
+
+# one-hot encoding
+h = [1, 0, 0, 0]
+e = [0, 1, 0, 0]
+l = [0, 0, 1, 0]
+o = [0, 0, 0, 1]
+input_data_np = np.array([[h, e, l, l, o], [e, o, l, l, l], [l, l, e, e, l]], dtype=np.float32)
+
+# transform as torch tensor
+input_data = torch.Tensor(input_data_np)
+``` 
+
+위와 같이 one-hot encoding하여 데이터를 만들들고 Tensor로 바꿔준다.
+알파벳에 그냥 숫자(index)를 붙여 사용하지 않고 굳이 one-hot encoding을 하는 이유는 숫자 크기에 따라 network가 의미를 부여할 수 있기 때문이다.
+실제로는 그저 알파벳일 뿐이지만 더 큰 숫자를 할당 받은 알파벳을 더 중요하게 생각하면서 학습할 수 있다는 것이다.
+
+다시 돌아오면 알파벳의 종류가 4가지이기 때문에 input data의 한 차원은 4로 shape이 `(-, -, 4)`가 되고,
+단어의 길이(**sequence length**)가 5이므로 shape은 `(-, 5, 4),`
+마지막으로 data의 개수가 3개(**batch size**)이기 때문에 shape이 `(3, 5, 4)`가 된다.
+
+다음으로 RNN layer를 만들 차례이다. `torch.nn.RNN`을 통해 RNN layer를 만들 수 있으며 이때 in/output size를 지정해주어야 한다.
+input size은 알파벳의 종류(4)가 되고 output size는 우리가 원하는 class의 개수(2)가 된다.
+sequence length와 abtch size는 input과 동일하며, data만 잘 만들어서 넣어줬다면 PyTorch에서 알아서 처리해주기 때문에 따로 입력할 필요가 없다.
+
+```py
+rnn = torch.nn.RNN(input_size, hidden_size)
+
+outputs, _status = rnn(input_data)
+print(outputs)
+print(outputs.size())
+
+'''output
+tensor([[[-0.7497, -0.6135],
+         [-0.5282, -0.2473],
+         [-0.9136, -0.4269],
+         [-0.9136, -0.4269],
+         [-0.9028,  0.1180]],
+
+        [[-0.5753, -0.0070],
+         [-0.9052,  0.2597],
+         [-0.9173, -0.1989],
+         [-0.9173, -0.1989],
+         [-0.8996, -0.2725]],
+
+        [[-0.9077, -0.3205],
+         [-0.8944, -0.2902],
+         [-0.5134, -0.0288],
+         [-0.5134, -0.0288],
+         [-0.9127, -0.2222]]], grad_fn=<StackBackward>)
+torch.Size([3, 5, 2])
+'''
+```
+
+한 가지 이상하다고 생각할 수 있는 부분이 있다. 분명 output size을 입력한다고 했는데 `hidden_size`라고 정의하여 넣었다.
+이는 RNN의 내부 구조를 보면 알 수 있다.
+
+![](/posting_imgs/lab11-1-1.png)
+
+빨간 박스 부분을 보면 hidden으로 넘어가는 부분과 output으로 나가는 data가 결국 같은 data에서 나눠지는 것을 볼 수 있다.
+그러므로 hidden size와 output size는 같다. 이 때문에 `hidden_size`라고 정의하여 넣은 것이다.
+
+### Data shape in RNN
+
+앞서 나온 shape을 정리해 보면 다음과 같다.
+
+![](/posting_imgs/lab11-1-2.png)
+
+(batch_size, sequence_length, dimension) 순으로 데이터가 구성되며,  앞서 언급한 대로 in/output size만 잘 넣어주면 나머지는 PyTorch가 데이터에 맞게 처리해준다.
\ No newline at end of file
diff --git a/_posts/2022-06-06-dlZeroToAll-PyTorch-11-2.markdown b/_posts/2022-06-06-dlZeroToAll-PyTorch-11-2.markdown
new file mode 100644
index 00000000000..4faba9bdd34
--- /dev/null
+++ b/_posts/2022-06-06-dlZeroToAll-PyTorch-11-2.markdown
@@ -0,0 +1,167 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab11-2: RNN - hihello / charseq"
+author: Kwon
+date: 2022-06-06T01:00:00 +0900
+categories: [pytorch, study]
+tags: [rnn]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab11-2: RNN - hihello / charseq 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## 'hihello' problem
+
+hihello 문제는 같은 문자들이 다음 문자가 다른 경우 이를 예측하는 문제를 말한다.
+hihello에서 'h'와 'l'은 2번씩 등장하지만 어디에 문자가 위치하느냐에 따라 다음에 올 문자가 달라진다.
+이런 경우가 RNN의 **hidden state**가 빛을 발휘하는 경우이다. 알파벳 만으로 판별할 수 없지만 순서를 기억하여 뒷 문자를 예측하는데 도움이 되기 때문이다.
+
+### with Code
+
+[lab11-1](/posts/dlZeroToAll-PyTorch-11-1/)의 코드를 확장하여 일반화한 것이다.
+전체적인 구조는 거의 동일하기 때문에 추가된 부분에 초점을 맞춰 살펴보려 한다.
+
+```py
+char_set = ['h', 'i', 'e', 'l', 'o']
+
+# hyper parameters
+input_size = len(char_set)
+hidden_size = len(char_set)
+learning_rate = 0.1
+
+# data setting
+x_data = [[0, 1, 0, 2, 3, 3]]
+x_one_hot = [[[1, 0, 0, 0, 0],
+              [0, 1, 0, 0, 0],
+              [1, 0, 0, 0, 0],
+              [0, 0, 1, 0, 0],
+              [0, 0, 0, 1, 0],
+              [0, 0, 0, 1, 0]]]
+y_data = [[1, 0, 2, 3, 3, 4]]
+
+X = torch.FloatTensor(x_one_hot)
+Y = torch.LongTensor(y_data)
+```
+
+마찬가지로 one-hot encoding하여 Tensor로 바꾼다. 다만 각 알파벳 변수에 배열을 저장하는 방식이 아니라 `char_set`에 저장된 알파벳을 `x_data`의 값을 인덱스로 불러오는 방식이다.
+one-hot encoding은 `x_data`에 적용하여 학습한다.
+
+데이터를 자세히 보면 input(x)은 마지막 문자가 없고 target(y)은 첫 문자가 없는 것을 볼 수 있는데,
+이건 각 차시의 RNN이 다음 문자를 출력하기 때문이다. input에
+
+다음은 모델과 loss, optimizer를 만들어준다. 마찬가지로 `torch.nn.RNN`를 사용하여 정의한다.
+
+```py
+rnn = torch.nn.RNN(input_size, hidden_size, batch_first=True)  # batch_first guarantees the order of output = (B, S, F)
+
+# loss & optimizer setting
+criterion = torch.nn.CrossEntropyLoss()
+optimizer = optim.Adam(rnn.parameters(), learning_rate)
+```
+
+```py
+# start training
+for i in range(100):
+    optimizer.zero_grad()
+    outputs, _status = rnn(X)
+    loss = criterion(outputs.view(-1, input_size), Y.view(-1))
+    loss.backward()
+    optimizer.step()
+
+    result = outputs.data.numpy().argmax(axis=2)
+    result_str = ''.join([char_set[c] for c in np.squeeze(result)])
+    print(i, "loss: ", loss.item(), "prediction: ", result, "true Y: ", y_data, "prediction str: ", result_str)
+
+'''output
+0 loss:  1.7802648544311523 prediction:  [[1 1 1 1 1 1]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  iiiiii
+1 loss:  1.4931954145431519 prediction:  [[1 4 1 1 4 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ioiioo
+2 loss:  1.3337129354476929 prediction:  [[1 3 2 3 1 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ilelio
+3 loss:  1.215295433998108 prediction:  [[2 3 2 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  elelll
+4 loss:  1.1131411790847778 prediction:  [[2 3 2 3 3 3]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  elelll
+5 loss:  1.0241888761520386 prediction:  [[2 3 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  elello
+6 loss:  0.9573155045509338 prediction:  [[2 3 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  elello
+7 loss:  0.9102011322975159 prediction:  [[2 0 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ehello
+...
+96 loss:  0.5322802066802979 prediction:  [[1 3 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ilello
+97 loss:  0.5321123003959656 prediction:  [[1 3 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ilello
+98 loss:  0.5319531559944153 prediction:  [[1 3 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ilello
+99 loss:  0.5317898392677307 prediction:  [[1 3 2 3 3 4]] true Y:  [[1, 0, 2, 3, 3, 4]] prediction str:  ilello
+```
+
+학습을 진행하는 것에 크게 특이한 점은 없고 결과를 낼때 `argmax`를 통해 one-hot vector를 index 값으로 바꿔줘야 한다. 이렇게 바꾼 output은 `''.join([char_set[c] for c in np.squeeze(result)])`를 통해 실제 단어로 바꿔 출력할 수 있다.
+
+결과를 보면 처음에는 이상한 단어들이 나오다가 마지막에 다와서는 첫 문자를 제외한 'ilello'가 제대로 나온 것을 확인할 수 있다.
+
+***
+
+## Charseq
+
+지금까지 했던 것을 다시 한번 일반화 시켜 임의의 문장도 학습할 수 있도록 한다.
+
+### Data
+
+```py
+sample = " if you want you"
+
+# make dictionary
+char_set = list(set(sample))
+char_dic = {c: i for i, c in enumerate(char_set)}
+print(char_dic)
+
+'''output
+<torch._C.Generator at 0x22912756f30>
+{'o': 0, 'n': 1, 'a': 2, ' ': 3, 'w': 4, 'i': 5, 'y': 6, 't': 7, 'u': 8, 'f': 9}
+'''
+```
+
+set을 통해 중복된 문자를 제거하고, 문자와 문자의 index를 담는 dictionary를 만들어 사용한다.
+
+```py
+# hyper parameters
+dic_size = len(char_dic)
+hidden_size = len(char_dic)
+learning_rate = 0.1
+
+# data setting
+sample_idx = [char_dic[c] for c in sample]
+x_data = [sample_idx[:-1]]
+x_one_hot = [np.eye(dic_size)[x] for x in x_data]
+y_data = [sample_idx[1:]]
+
+# transform as torch tensor variable
+X = torch.FloatTensor(x_one_hot)
+Y = torch.LongTensor(y_data)
+```
+
+one-hot encodeng을 identity matrix(단위행렬)를 통해 진행한다. `np.eye(size)`를 통해 만들 수 있는 단위행렬은 주대각선(좌상우하)의 원소가 모두 1이고 나머지는 모두 0인 정사각 행렬이다.
+앞서 뽑아냈던 문자들의 index를 사용하여 단위행렬의 한 줄을 뽑아내면 그것이 곧 해당 문자의 one-hot vetor가 되기 때문에 손쉽게 one-hot encodeng을 할 수 있다.
+
+이후 데이터의 길이에 맞춰 각 size를 정의하고 x에서는 맨 뒤 문자, y에서는 맨 앞 문자를 빼서 학습할 수 있도록 한다.
+그리고 만들어진 데이터를 Tensor로 바꿔준다.
+
+### Train Result
+
+모델과 학습은 다르지 않으므로 결과만 한번 살펴보자
+
+```py
+'''output
+0 loss:  2.4069371223449707 prediction:  [[7 7 0 7 8 5 8 7 8 7 8 0 7 8 5]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  ttotuiututuotui
+1 loss:  2.1236345767974854 prediction:  [[1 0 0 1 0 8 0 1 8 8 8 1 1 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  noonouonuuunnou
+2 loss:  1.8809428215026855 prediction:  [[6 0 3 6 0 8 3 6 0 8 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  yo you yout you
+3 loss:  1.71848464012146 prediction:  [[6 0 3 6 0 8 3 6 4 5 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  yo you ywit you
+4 loss:  1.5743740797042847 prediction:  [[6 0 3 6 0 8 3 6 2 5 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  yo you yait you
+5 loss:  1.4554158449172974 prediction:  [[6 9 3 6 0 8 3 6 8 5 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  yf you yuit you
+6 loss:  1.3661972284317017 prediction:  [[5 9 3 6 0 8 3 6 2 5 7 3 6 2 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if you yait yau
+7 loss:  1.2864983081817627 prediction:  [[5 9 3 6 2 8 3 6 2 1 7 3 6 2 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if yau yant yau
+8 loss:  1.2224119901657104 prediction:  [[5 9 3 6 2 8 3 6 2 1 7 3 6 2 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if yau yant yau
+...
+46 loss:  0.8302408456802368 prediction:  [[5 9 3 6 0 8 3 4 2 1 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if you want you
+47 loss:  0.8290660381317139 prediction:  [[5 9 3 6 0 8 3 4 2 1 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if you want you
+48 loss:  0.8275652527809143 prediction:  [[5 9 3 6 0 8 3 4 2 1 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if you want you
+49 loss:  0.8264601230621338 prediction:  [[5 9 3 6 0 8 3 4 2 1 7 3 6 0 8]] true Y:  [[5, 9, 3, 6, 0, 8, 3, 4, 2, 1, 7, 3, 6, 0, 8]] prediction str:  if you want you
+'''
+```
+
+마찬가지로 학습의 막바지로 갈수록 학습했던 문장이 잘 나오는 것을 확인할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-06-07-dlZeroToAll-PyTorch-11-3.markdown b/_posts/2022-06-07-dlZeroToAll-PyTorch-11-3.markdown
new file mode 100644
index 00000000000..62b6f389bd7
--- /dev/null
+++ b/_posts/2022-06-07-dlZeroToAll-PyTorch-11-3.markdown
@@ -0,0 +1,201 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab11-3: RNN - longseq"
+author: Kwon
+date: 2022-06-07T00:00:00 +0900
+categories: [pytorch, study]
+tags: [rnn]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab11-3: RNN - hihello / charseq 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Longseq
+
+앞서 살펴보았던 RNN 예제들은 모두 한 단어나 짧은 문장에 대해 RNN을 학습시키는 내용들이었다.
+하지만 우리가 다루고 싶은 데이터는 더 긴 문장이거나 내용을 가질 가능성이 높다.
+이런 상황에서는 그 데이터 전체를 넣어 RNN을 학습시키기에는 들어가는 데이터의 길이도 매번 다를 뿐더러 그 크기가 너무 커서 학습이 불가능할 수도 있다.
+그래서 일정한 크기의 window를 사용하여 RNN에 잘라서 넣어준다.
+
+아래 문장을 보자.
+
+```py
+sentence = ("if you want to build a ship, don't drum up people together to ")
+```
+
+이 문장의 마지막 문자만 잘라서 바로 넣기 보다는 크기 10의 window로 잘라 넣으려고 한다.
+이때 window를 오른쪽으로 한칸씩 밀어가면서 data를 만든다. 위 문장을 자르면 다음과 같다.
+
+```
+   x_data    ->    y_data
+
+"if you wan" -> "f you want"
+"f you want" -> " you want "
+" you want " -> "you want t"
+"you want t" -> "ou want to"
+"ou want to" -> "u want to "
+```
+
+이렇게 하면 일정한 크기로 데이터를 잘라 학습을 할 수 있다. (x_data로 y_data를 학습하여 예측)
+
+***
+
+## with Code
+
+### Imports
+
+```py
+import torch
+import torch.optim as optim
+import numpy as np
+
+torch.manual_seed(0)
+```
+
+### Data
+
+앞서 본 문장과 더불어 총 3개의 문장을 학습에 사용해 본다.
+
+```py
+sentence = ("if you want to build a ship, don't drum up people together to "
+            "collect wood and don't assign them tasks and work, but rather "
+            "teach them to long for the endless immensity of the sea.")
+```
+
+[lab11-2](/posts/dlZeroToAll-PyTorch-11-2/)의 charseq 예제에서 봤던 것과 같은 방법으로 one-hot encoding에 사용할 dictionary를 생성한다.
+
+```py
+# make dictionary
+char_set = list(set(sentence))
+char_dic = {c: i for i, c in enumerate(char_set)}
+
+# hyper parameters
+dic_size = len(char_dic)
+hidden_size = len(char_dic)
+sequence_length = 10  # Any arbitrary number
+learning_rate = 0.1
+```
+
+이후 window를 이용하여 자르는 방식으로 data를 만들고 one-hot encoding 한다.
+
+```py
+# data setting
+x_data = []
+y_data = []
+
+# window를 오른쪽으로 움직이면서 자름
+for i in range(0, len(sentence) - sequence_length):
+    x_str = sentence[i:i + sequence_length]
+    y_str = sentence[i + 1: i + sequence_length + 1]
+    print(i, x_str, '->', y_str)
+
+    x_data.append([char_dic[c] for c in x_str])  # x str to index (dict 사용)
+    y_data.append([char_dic[c] for c in y_str])  # y str to index
+
+x_one_hot = [np.eye(dic_size)[x] for x in x_data]
+
+X = torch.FloatTensor(x_one_hot)
+Y = torch.LongTensor(y_data)
+
+'''output
+0 if you wan -> f you want
+1 f you want ->  you want 
+2  you want  -> you want t
+3 you want t -> ou want to
+4 ou want to -> u want to 
+...
+166 ty of the  -> y of the s
+167 y of the s ->  of the se
+168  of the se -> of the sea
+169 of the sea -> f the sea.
+'''
+```
+
+### Model
+
+문장이 더 길고 복잡하기 때문에 기존 한 층의 RNN으로는 학습이 잘 안 될 수 있다. 그래서 RNN 층을 더 쌓고 마지막에 fully connected layer를 연결하여 더 복잡한 모델을 만들어 사용해 볼 것이다.
+
+![](/posting_imgs/lab11-3-1.png)
+
+```py
+# declare RNN + FC
+class Net(torch.nn.Module):
+    def __init__(self, input_dim, hidden_dim, layers):
+        super(Net, self).__init__()
+        self.rnn = torch.nn.RNN(input_dim, hidden_dim, num_layers=layers, batch_first=True)
+        self.fc = torch.nn.Linear(hidden_dim, hidden_dim, bias=True)
+
+    def forward(self, x):
+        x, _status = self.rnn(x)
+        x = self.fc(x)
+        return x
+
+net = Net(dic_size, hidden_size, 2)
+```
+
+`torch.nn.RNN`을 이용하여 RNN을 생성할 때 `num_layers`를 layer 수만큼 설정해 주는 것으로 원하는 층의 RNN을 생성할 수 있다.
+RNN과 FC를 정의하고 foward에서 연결시켜주는 모습이다.
+
+### Train
+
+```py
+criterion = torch.nn.CrossEntropyLoss()
+optimizer = optim.Adam(net.parameters(), learning_rate)
+
+# start training
+for i in range(100):
+    optimizer.zero_grad()
+    outputs = net(X)
+    loss = criterion(outputs.view(-1, dic_size), Y.view(-1))
+    loss.backward()
+    optimizer.step()
+
+    results = outputs.argmax(dim=2)
+    predict_str = ""
+    for j, result in enumerate(results):
+        # print(i, j, ''.join([char_set[t] for t in result]), loss.item())
+        if j == 0:
+            predict_str += ''.join([char_set[t] for t in result])
+        else:
+            predict_str += char_set[result[-1]]
+
+    print(predict_str)
+
+'''output
+hswmsshsmmmwsisshsmmhwwshhhhwmsssswmhmshhsmshismhhsismshmhmsismisshhswhissmwmmmmhssswwishhhwshmhhsmshsmwwmmhismhmsssmhmshmhmshmhhmshmhhsissimmhsismshmwwmmmhsshhhshmwsmmuismshmwwmm
+                                                                                                                                                                                   
+      t t  ttt ttt  t  ttt t ttt t t t t   t  t t ttt   t t  t t t tt t  ttt  tt t ttt t t   tt t t tt t t t t ttt ttt t ttt t tt t tt t  tt t t  ttt tt t t t t   t t t   t t  ttt
+  b.o  b.   o  o             o                                        o        o                           o             o                     o   o       o   o                   
+e ae  as      a    a aa  a       a        a   a  a      a  ata aa   aa   aa  a              a     a  aa   a                aa   aa   a   a aa   a  a  a     aa     a           aa  
+e tl  ee teeeettlteeetl tleeeee eeeee eleet etteeetleeteeeeeeletleeeeeeeeeeeeteeoeestee eletteeeeeletteeeeteeeeeeeetelteeetleseteleteleeeetteteeoeteeee eeeeleeee eeeeeeteeeeeell e
+e to  ot oo oot tooo ot ouoto o ootoo ouoou ooootto  oootu ootootoo oo ooo ooo ouoo ooo ooooo oouoto otoo uoouo ooo uoooo oto oootoo oooo  utoo oo ttot ooo oto ooo ooo  oooooouo o
+e t o     ott      ttttt    u  tu ttt ot utt             tt t  t   tttttt   ttt   t     ut ut   tt      u   u t   t tt t   t        t ot  tt  u  t    t ut    ut  o  u   o  o  t  t
+  t  t     t   t    t  t  tttt t  tt       t    t ttt  et t        t tt   t   t    tt      t e  t  tt t  t     tt        t t t   t  t    tt t tt  tt   t   t t t   t   t         t 
+            t tt         t       tt              t         t t                 t t                                   t t   tt                      t           t   t         e  t  
+           t   o    t             t        o              tt          o       t    ot                                t      t                  o  t                               t
+e  o  t    oh  o  o o  o  oo oot  to o  oo o    o oooo  o o  to  o h too  oo  oo   oto o  oo oo to oo    o o  ooto o     o t o o      to  o  oto  oh o o   o   ooo  o  ot  tooo  o 
+e  o  t  t th  o  o t  oeto too t to t tot o    o oo o  h o   o  o h too  to  th  toto    tt oeoto oo to o oo ooto       oot  oo to e to to  tto  th o o   o  ohoo toto t  to etht 
+theo lt  thth te lo t  oete tollthto t tetto    e otte taet  to  o t too  too th ttoto it tt teeto ee to e eo eott e   t tet t o to e lo to  tto tth o o   e  thee tetoath totetht 
+thto tt to to to te t to cettoelthto   to toe tteto  e ae t  to te   to   te  th ttoto e  tehe  to    tet to  eoto  th  t  tht este e lo to  eto tto eto      eo e neeeaoh toe thes
+thto  t  t to lt t  t to t  to  t to   totto     to       t  lo      to t t   th ttot   tt t    to    t   to   oto  th  d  th    toe  to t    to tto  to  s    o   n   tt  tot th s
+t to  t  o to to to ttto to to  t to t totto    oto t   o t  to eo   to   to  th ttoto  tttt    to o  to  too  oto  th  d  t   o to   to to   to tto  tod  o  to     t tt  to  th  
+thto  th t to to t  t  o to to  t to t totto     to       t  to      wo   tot th  thto  t tt    to    to  too   to  t      t   o to   to to   uo tth  to   o  to     to t  to  th  
+thto  th t to to t  t    to to  t to   totto     to     m to to      wo   tot th  thto  t tth   to    to  to    to  t      th  o to   to to   to uth  to      to     to t  to  th  
+thto ethet to to to tht  to to dthto   totto     to    em tonto e    wo   tot th  thto  d tth   to    to  to    to  t      th  o toe  to to e to ethi to     eto   n t  o  to  th  
+thto eth t to lo 'o tht eto to 'thto   tttt  kl eth    em thnto e    to   tot th  thto  t tthe  to    to  to    to  th n  ethe p toe  to to e to  thi        ett e n th t  toe the 
+tuto eto t to tt 'e tht epo to 'ththt  tmtt  kl eth     n th to e  e to   tot th  toto  t tthe  totho tot to l etot to oe ethe t toi  to to e to  thi   d     tt e   thta  toe the 
+tuto lao t todto 'e thtoeco tos't tos  totto kl  to    en to to ee d to   tod to  toto  d 't em totoo tot to  p tosoto nipetoe p toio to lo t to  toio od  o  to e   t tou toemtoe 
+tuto  to t to tp  e tos  to to 't to   tootoo l eto    en to to ee o wo   tot to  toao  t tthem tosoo tod to    so  t so noth np toe  to to deso ltoemtod sm  to     t eaa toem oe 
+'utos to t to los e tot epo to 't tosl to tn  le tos   en to lo  h n wo   tot to  toaon t dt er tos   tot tor , wod tos enotossa toe  to lo   sod tosm  d sm  tn e   theoa toe to  
+...
+g you want to build a ship, don't drum up people together to collect wood and don't assign them tasks and work, but rather teach them to long for the sndless immensity of the sea.
+f you want to build a ship, don't drum up people together to collect wood and don't assign them tasks and work, but rather teach them to long for the sndless immensity of the sea.
+f you want to build a ship, don't drum up people together to collect wood and don't assign them tasks and work, but rather teach them to long for the sndless immensity of the sea.
+f you want to build a ship, don't drum up people together to collect wood and don't assign them tasks and work, but rather teach them to long for the sndless immensity of the sea.
+'''
+```
+
+loss와 optimizer를 정의하고 학습을 진행한다.
+처음에는 상당히 이상한 문장들이 출력된다. 하지만 학습이 진행됨에 따라 원래의 문장에 가깝게 문장들이 출력되는 것을 확인할 수 있으며, 이는 학습이 잘 되었다고 볼 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-06-10-dlZeroToAll-PyTorch-11-4.markdown b/_posts/2022-06-10-dlZeroToAll-PyTorch-11-4.markdown
new file mode 100644
index 00000000000..6e073aaaeb0
--- /dev/null
+++ b/_posts/2022-06-10-dlZeroToAll-PyTorch-11-4.markdown
@@ -0,0 +1,193 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab11-4: Timeseries"
+author: Kwon
+date: 2022-06-10T00:00:00 +0900
+categories: [pytorch, study]
+tags: [rnn, timeseries]
+math: true
+mermaid: false
+---
+
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab11-4: Timeseries 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Timeseries
+
+timeseries(시게열) data는 일정 시간 간격으로 배치된 data를 말한다.
+매장의 시간별 매출, 요일별 주식 시가/종가 등이 여기에 속할 수 있다.
+이들도 순서가 데이터에 포함된 경우이므로 RNN을 이용하여 과거의 데이터를 가지고 예측을 하는 것이 좋은 방법일 수 있다. (순서를 포함한 데이터라고 RNN이 만능이라는 것은 아니다.)
+
+이번 실습에서는 요일별 주식 정보들을 이용하여 학습을 진행하였다.
+
+![](/posting_imgs/lab11-4-1.png)
+
+위와 같이 일별 시작가, 고가, 저가, 거래량, 종가가 포함된 데이터이다.
+
+이 데이터를 그냥 학습시킬수도 있지만 각 데이터들의 scale을 맞추고 하는 것이 더 좋다.
+거래량을 제외한 가격 정보들은 800 정도의 값에 있지만 거래량은 100만 단위이다.
+만약 이대로 바로 학습한다면 거래량에 치우쳐서 학습을 하거나 scale을 맞추기 위한 학습을 model이 추가적으로 해야 하므로 필요없는 부담이 발생할 수 있다.
+그래서 뒤에 나올 코드에서는 scaling을 하고 학습을 진행할 것이다.
+
+***
+
+## with Code
+
+### Imports
+
+```py
+import torch
+import torch.optim as optim
+import numpy as np
+import matplotlib.pyplot as plt
+
+torch.manual_seed(0)
+
+# hyper parameters
+seq_length = 7
+data_dim = 5
+hidden_dim = 10
+output_dim = 1
+learning_rate = 0.01
+iterations = 500
+```
+
+### Data
+
+데이터를 불러오고 70%의 데이터를 train data로 만들어준다.
+
+```py
+# load data
+xy = np.loadtxt("data-02-stock_daily.csv", delimiter=",")
+xy = xy[::-1]  # reverse order
+
+# split train-test set
+train_size = int(len(xy) * 0.7)
+train_set = xy[0:train_size]
+test_set = xy[train_size - seq_length:]
+```
+
+앞서 언급한대로 scaling을 하고 학습하기 좋은 형태로 data를 가공해야 한다.
+
+```py
+def minmax_scaler(data):
+    numerator = data - np.min(data, 0)
+    denominator = np.max(data, 0) - np.min(data, 0)
+    return numerator / (denominator + 1e-7)
+
+train_set = minmax_scaler(train_set)
+test_set = minmax_scaler(test_set)
+```
+
+이번 에제에서는 min-max scaling을 적용할 것이다. min-max scaling은 아래 식을 통해 진행되는 scaling으로 최소, 최대값을 사용하여 0과 1사이의 값으로 바꾸어 준다.
+
+\\[x_{scaled}=\frac{x-x_{min}}{x_{max}-x_{min}}\\]
+
+이번에도 데이터의 길이가 길기 때문에 RNN model에 넣어줄 만큼 잘라서 데이터를 만들어준다.
+
+```py
+def build_dataset(time_series, seq_length):
+    dataX = []
+    dataY = []
+    for i in range(0, len(time_series) - seq_length):
+        _x = time_series[i:i + seq_length, :]
+        _y = time_series[i + seq_length, [-1]]  # Next close price
+        print(_x, "->", _y)
+        dataX.append(_x)
+        dataY.append(_y)
+    return np.array(dataX), np.array(dataY)
+
+trainX, trainY = build_dataset(train_set, seq_length)
+testX, testY = build_dataset(test_set, seq_length)
+
+'''output
+[[2.53065030e-01 2.45070970e-01 2.33983036e-01 4.66075110e-04
+  2.32039560e-01]
+ [2.29604366e-01 2.39728936e-01 2.54567513e-01 2.98467330e-03
+  2.37426028e-01]
+ [2.49235510e-01 2.41668371e-01 2.48338489e-01 2.59926504e-04
+  2.26793794e-01]
+ [2.21013495e-01 2.46602231e-01 2.54710584e-01 0.00000000e+00
+  2.62668239e-01]
+ [3.63433786e-01 3.70389871e-01 2.67168847e-01 1.24764722e-02
+  2.62105010e-01]
+ [2.59447633e-01 3.10673724e-01 2.74113889e-01 4.56323384e-01
+  2.71751265e-01]
+ [2.76008150e-01 2.78314566e-01 1.98470380e-01 5.70171193e-01
+  1.78104644e-01]] -> [0.16053716]
+...
+ [0.88723699 0.88829938 0.92518158 0.08714288 0.90908564]
+ [0.88939504 0.88829938 0.94014512 0.13380794 0.90030461]
+ [0.89281215 0.89655181 0.94323484 0.12965206 0.93124657]
+ [0.91133638 0.91818448 0.95944078 0.1885611  0.95460261]] -> [0.97604677]
+'''
+```
+
+7일간의 주식 데이터(x)들을 통해 그 다음날의 종가(y)를 예측하도록 데이터를 만든다. window의 크기를 7로 해서 잘랐다고 생각하면 될것 같다.
+
+### Model
+
+이번에는 RNN의 한 종류인 LSTM을 사용하며 마지막에 fully connected layer를 연결하여 출력을 낸다.
+
+![](/posting_imgs/lab11-4-2.png)
+
+이런 식으로 마지막에 fc 층을 추가하는 이유가 몇가지 있다.
+
+먼저, data를 전달하는 부분과 label을 최종적으로 맞추는 부분을 분리하여 network에 가해지는 부담을 분산할 수 있다.
+그리고 RNN 층을 바로 출력에 연결할 경우 과거의 정보를 전달하는 hidden state도 최종 출력의 차원과 맞춰주어야 한다.
+이번 경우를 보면 최종적으로 1차원의 출력을 내어야 하는데 이는 정보를 전달하는 hidden state도 차원이 1이어야 한다는 뜻이다.
+이런 상황에서는 model이 학습 뿐만 아니라 전보 전달을 위한 압축도 해야하는 부담을 가지게 되어 학습에 악영향을 끼칠 수 있다.
+그래서 일반적으로 hidden state의 차원은 충분히 보장해주고 마지막에 fc layer를 연결하여 출력을 완성하는 방식을 사용한다.
+
+```py
+class Net(torch.nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim, layers):
+        super(Net, self).__init__()
+        self.rnn = torch.nn.LSTM(input_dim, hidden_dim, num_layers=layers, batch_first=True)
+        self.fc = torch.nn.Linear(hidden_dim, output_dim, bias=True)
+
+    def forward(self, x):
+        x, _status = self.rnn(x)
+        x = self.fc(x[:, -1])
+        return x
+
+
+net = Net(data_dim, hidden_dim, output_dim, 1)
+```
+
+### Train
+
+loss와 optimizer를 정의하고 학습한다.
+
+```py
+criterion = torch.nn.MSELoss()
+optimizer = optim.Adam(net.parameters(), lr=learning_rate)
+
+for i in range(iterations):
+
+    optimizer.zero_grad()
+    outputs = net(trainX_tensor)
+    loss = criterion(outputs, trainY_tensor)
+    loss.backward()
+    optimizer.step()
+    print(i, loss.item())
+```
+
+예측한 것들을 크래프로 그려보면 다음과 같다
+
+```py
+plt.plot(testY)
+plt.plot(net(testX_tensor).data.numpy())
+plt.legend(['original', 'prediction'])
+plt.show()
+```
+
+![](/posting_imgs/lab11-4-3.png)
+
+예측이 아주 잘 된것 같아 보이지만 실제로는 아니다.
+
+![](/posting_imgs/lab11-4-4.png)
+
+위 그림은 그래프 중 일부를 가져온 것인데, 잘 보면 예측이 오른쪽으로 한 칸씩 밀린 것처럼 보인다.
+이는 노이즈가 심한 금융 시계열 데이터에서 lstm model의 고질적인 문제로 직전 값을 예측 값으로 출력하는 경우가 잦다고 한다. (이전의 값을 예측 값으로 내는 것이 가장 이득이라고 판단했기 때문)
+실제로 사용할 때에는 이런 경우에 정말로 예측을 잘 한 것인지 아니면 위와 같이 밀려서 잘 되어 보이는 건지 확인해 볼 필요가 있을 것 같다.
\ No newline at end of file
diff --git a/_posts/2022-06-10-dlZeroToAll-PyTorch-11-5.markdown b/_posts/2022-06-10-dlZeroToAll-PyTorch-11-5.markdown
new file mode 100644
index 00000000000..65bc1fc943d
--- /dev/null
+++ b/_posts/2022-06-10-dlZeroToAll-PyTorch-11-5.markdown
@@ -0,0 +1,354 @@
+---
+title: "모두를 위한 딥러닝 2 - Lab11-5: Seq2Seq"
+author: Kwon
+date: 2022-06-10T01:00:00 +0900
+categories: [pytorch, study]
+tags: [rnn]
+math: true
+mermaid: false
+---
+[모두를 위한 딥러닝](https://deeplearningzerotoall.github.io/season2/lec_pytorch.html) Lab11-5: Seq2Seq 강의를 본 후 공부를 목적으로 작성한 게시물입니다.
+
+***
+
+## Seq2Seq Model
+
+Seq2Seq model은 아래와 같은 구조를 가지고 있다.
+
+![](/posting_imgs/lab11-5-1.png)
+
+일종의 Encoder-Decoder 구조라고도 할 수 있는데 모든 입력을 다 받은 후에 출력을 생성하는 구조이다.
+
+왼쪽(파란색)에서는 입력 받은 정보들을 순차적으로 학습하여 정보를 vector로 압축하는 역할을 하고,
+오른쪽(주황색)에서는 압축한 정보를 전달받아 start flag(Start Of Sentence, SOS)와 함께 다음에 등장할 데이터를 예측하면서 순차적으로 output을 내고 마지막에는 end flag(Etart Of Sentence, EOS)를 출력하여 데이터의 끝이라는 것을 알려준다.
+
+간단한 문장에 대한 대답을 에로 들면 다음과 같다. 내부 layer는 LSTM나 GRU를 사용한다.
+
+![](/posting_imgs/lab11-5-2.png)
+
+이를 사용하는 에로는 chatbot이 있을 수 있는데 chatbot은 사용자의 입력(문장)을 다 듣기 전에 답변을 만들 경우 실제 문장과 상관없는 답변을 생성할 수도 있다.
+이런 경우 처럼 input sequence의 전체를 다 확인하고 출력이 있어야 하는 경우에 Seq2Seq model을 사용하게 된다.
+
+***
+
+## with Code
+
+간단한 번역을 할 수 있는 model을 학습시키는 실습이다.
+
+### Imports
+
+```py
+import random
+import torch
+import torch.nn as nn
+from torch import optim
+
+torch.manual_seed(0)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+```
+
+### Data
+
+아래 data를 처리하여 사용할 것이다. data는 같은 뜻의 영어와 한국어로 구성되어 있고 각 영어와 하눆어는 tab으로 구분되어 있다.
+
+```py
+raw = ["I feel hungry.	나는 배가 고프다.",
+       "Pytorch is very easy.	파이토치는 매우 쉽다.",
+       "Pytorch is a framework for deep learning.	파이토치는 딥러닝을 위한 프레임워크이다.",
+       "Pytorch is very clear to use.	파이토치는 사용하기 매우 직관적이다."]
+```
+
+data를 전처리하는 함수를 만들어 사용한다.
+
+```py
+# fix token for "start of sentence" and "end of sentence"
+SOS_token = 0
+EOS_token = 1
+
+class Vocab:
+    def __init__(self):
+        self.vocab2index = {"<SOS>": SOS_token, "<EOS>": EOS_token}
+        self.index2vocab = {SOS_token: "<SOS>", EOS_token: "<EOS>"}
+        self.vocab_count = {}
+        self.n_vocab = len(self.vocab2index)
+
+    def add_vocab(self, sentence):
+        for word in sentence.split(" "):
+            if word not in self.vocab2index:
+                self.vocab2index[word] = self.n_vocab
+                self.vocab_count[word] = 1
+                self.index2vocab[self.n_vocab] = word
+                self.n_vocab += 1
+            else:
+                self.vocab_count[word] += 1
+
+def filter_pair(pair, source_max_length, target_max_length):
+    return len(pair[0].split(" ")) < source_max_length and len(pair[1].split(" ")) < target_max_length
+
+def preprocess(corpus, source_max_length, target_max_length):
+    print("reading corpus...")
+    pairs = []
+    for line in corpus:
+        pairs.append([s for s in line.strip().lower().split("\t")])
+    print("Read {} sentence pairs".format(len(pairs)))
+
+    pairs = [pair for pair in pairs if filter_pair(pair, source_max_length, target_max_length)]
+    print("Trimmed to {} sentence pairs".format(len(pairs)))
+
+    source_vocab = Vocab()
+    target_vocab = Vocab()
+
+    print("Counting words...")
+    for pair in pairs:
+        source_vocab.add_vocab(pair[0])
+        target_vocab.add_vocab(pair[1])
+    print("source vocab size =", source_vocab.n_vocab)
+    print("target vocab size =", target_vocab.n_vocab)
+
+    return pairs, source_vocab, target_vocab
+```
+
+먼저 `\t`(tab)으로 나눠서 pairs에 넣어주고 `filter_pair`로 각 문장의 단어 개수가 `source_max_length`와 `target_max_length`를 넘지 않는 경우만 필터링한다.
+정제된 데이터들을 따로 정의한 `Vocab` instance를 통해 단어의 종류와 그 개수로 이루어진 dictionary data로 만들어준다.
+
+```py
+SOURCE_MAX_LENGTH = 10
+TARGET_MAX_LENGTH = 12
+
+load_pairs, load_source_vocab, load_target_vocab = preprocess(raw, SOURCE_MAX_LENGTH, TARGET_MAX_LENGTH)
+print(random.choice(load_pairs))
+
+'''output
+reading corpus...
+Read 4 sentence pairs
+Trimmed to 4 sentence pairs
+Counting words...
+source vocab size = 17
+target vocab size = 13
+['pytorch is very clear to use.', '파이토치는 사용하기 매우 직관적이다.']
+'''
+```
+
+4개의 문장이 모두 잘 변환이 되었고
+무작위로 하나를 골라 출력해보면 위와 같이 쌍이 잘 나오는 것을 확인할 수 있다.
+
+### Model
+
+Model은 앞에서 언급한 것과 같이 encoder와 decoder로 이루어져 있다.
+
+```py
+class Encoder(nn.Module):
+    def __init__(self, input_size, hidden_size):
+        super(Encoder, self).__init__()
+        self.hidden_size = hidden_size
+        self.embedding = nn.Embedding(input_size, hidden_size)
+        self.gru = nn.GRU(hidden_size, hidden_size)
+
+    def forward(self, x, hidden):
+        x = self.embedding(x).view(1, 1, -1)
+        x, hidden = self.gru(x, hidden)
+        return x, hidden
+
+class Decoder(nn.Module):
+    def __init__(self, hidden_size, output_size):
+        super(Decoder, self).__init__()
+        self.hidden_size = hidden_size
+        self.embedding = nn.Embedding(output_size, hidden_size)
+        self.gru = nn.GRU(hidden_size, hidden_size)
+        self.out = nn.Linear(hidden_size, output_size)
+        self.softmax = nn.LogSoftmax(dim=1)
+
+    def forward(self, x, hidden):
+        x = self.embedding(x).view(1, 1, -1)
+        x, hidden = self.gru(x, hidden)
+        x = self.softmax(self.out(x[0]))
+        return x, hidden
+```
+
+이번 model의 내부는 GRU로 구성한다. 다른 것들은 크게 다른 점은 없지만 조금 다른 것은 embedding 부분이다.
+source의 oen-hot vector는 단어 개수 만큼 input size가 커지게 되는데 이때의 차원은 그냥 학습하기에 너무 클 수 있다.
+그래서 `nn.Embedding`을 통해 차원을 줄여 밀집되게 바꿔 사용할 수 있다.
+
+Decoder에서는 model을 통해 만든 것들을 softmax를 통해 단어들이 나올 확률로 내보낸다.
+
+### Train
+
+학습하는 코드는 조금 길기 때문에 잘라서 보자.
+
+먼저 `trian` 안에서 사용할 `tensorize` 함수다.
+
+```py
+# convert sentence to the index tensor with vocab
+def tensorize(vocab, sentence):
+    indexes = [vocab.vocab2index[word] for word in sentence.split(" ")]
+    indexes.append(vocab.vocab2index["<EOS>"])
+    return torch.Tensor(indexes).long().to(device).view(-1, 1)
+```
+
+전처리 할 때 `Vocab`에 저장했던 문장들을 학습할 수 있도록 Tensor로 바꿔주는 함수이다.
+
+다음은 `train`의 앞부분이다. 무작위로 `n_iter`만큼 뽑아서 batch data를 만들어주고, 앞서 정의한 `tensorize`를 아용하여 data들을 모두 Tensor로 바꿔주고 encoder/decoder의 optimizer와 loss를 정의해준다.
+
+```py
+# training seq2seq
+def train(pairs, source_vocab, target_vocab, encoder, decoder, n_iter, print_every=1000, learning_rate=0.01):
+    loss_total = 0
+
+    encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)
+    decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
+
+    training_batch = [random.choice(pairs) for _ in range(n_iter)]
+    training_source = [tensorize(source_vocab, pair[0]) for pair in training_batch]
+    training_target = [tensorize(target_vocab, pair[1]) for pair in training_batch]
+
+    criterion = nn.NLLLoss()
+
+    ...
+```
+
+위에서 처리하고 정의한 것들을 기반으로 encoder를 학습하는 부분이다.
+
+```py
+# training seq2seq
+def train(pairs, source_vocab, target_vocab, encoder, decoder, n_iter, print_every=1000, learning_rate=0.01):
+
+    ...
+
+    for i in range(1, n_iter + 1):
+        source_tensor = training_source[i - 1]
+        target_tensor = training_target[i - 1]
+
+        encoder_hidden = torch.zeros([1, 1, encoder.hidden_size]).to(device)
+
+        encoder_optimizer.zero_grad()
+        decoder_optimizer.zero_grad()
+
+        source_length = source_tensor.size(0)
+        target_length = target_tensor.size(0)
+
+        loss = 0
+
+        for enc_input in range(source_length):
+            _, encoder_hidden = encoder(source_tensor[enc_input], encoder_hidden)
+
+        ...
+```
+
+문장을 하나씩 가져와서 문장의 단어를 하나씩 순차적으로 넣어가면서 encoder의 출력을 만든다. 이때 각 학습의 맨 처음 `encoder_hidden`은 0으로 채운 Tensor를 사용한다.
+
+다음은 decoder의 학습이다.
+
+```py
+# training seq2seq
+def train(pairs, source_vocab, target_vocab, encoder, decoder, n_iter, print_every=1000, learning_rate=0.01):
+    
+    ...
+
+    for i in range(1, n_iter + 1):
+        ...
+
+        decoder_input = torch.Tensor([[SOS_token]]).long().to(device)
+        decoder_hidden = encoder_hidden # connect encoder output to decoder input
+
+        for di in range(target_length):
+            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)
+            loss += criterion(decoder_output, target_tensor[di])
+            decoder_input = target_tensor[di]  # teacher forcing
+
+        loss.backward()
+
+        encoder_optimizer.step()
+        decoder_optimizer.step()
+
+        loss_iter = loss.item() / target_length
+        loss_total += loss_iter
+
+        if i % print_every == 0:
+            loss_avg = loss_total / print_every
+            loss_total = 0
+            print("[{} - {}%] loss = {:05.4f}".format(i, i / n_iter * 100, loss_avg))
+```
+
+decoder의 첫 input은 SOS로, hidden state는 encoder의 최종 hidden state로 넣어준다.
+for문을 동면서 decoder를 통과시키는 부분을 보면 decoder에서 나온 output을 다음 input으로 사용하는 것이 아니라 실제 label을 다음 cell에 넣어주는 것을 볼 수 있다.
+이건 **Teacher Forcing**이라는 방법으로 이전 cell의 output을 사용하는 것보다 학습이 빠르지만 불안정하다는 특징을 가지고 있다.
+
+이전까지 진행했던 과정들을 바탕으로 `step`을 통해 학습을 진행하고 `n_iter`만큼 반복한다.
+
+```py
+train(load_pairs, load_source_vocab, load_target_vocab, enc, dec, 5000, print_every=1000)
+
+'''output
+[1000 - 20.0%] loss = 0.0285
+[2000 - 40.0%] loss = 0.0168
+[3000 - 60.0%] loss = 0.0119
+[4000 - 80.0%] loss = 0.0091
+[5000 - 100.0%] loss = 0.0074
+'''
+```
+
+실제로 학습하면서 확인한 결과 loss가 잘 감소하였다.
+
+### Evaluate
+
+마지막으로 평가를 위한 함수로, 실제 pair를 출력하고 그에 대한 예측도 함께 출력하여 잘 학습되었는지 확인할 수 있는 함수이다.
+
+```py
+def evaluate(pairs, source_vocab, target_vocab, encoder, decoder, target_max_length):
+    for pair in pairs:
+        print(">", pair[0])
+        print("=", pair[1])
+        source_tensor = tensorize(source_vocab, pair[0])
+        source_length = source_tensor.size()[0]
+        encoder_hidden = torch.zeros([1, 1, encoder.hidden_size]).to(device)
+
+        for ei in range(source_length):
+            _, encoder_hidden = encoder(source_tensor[ei], encoder_hidden)
+
+        decoder_input = torch.Tensor([[SOS_token]]).long().to(device) # 수정해야 작동
+        decoder_hidden = encoder_hidden
+        decoded_words = []
+
+        for di in range(target_max_length):
+            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)
+            _, top_index = decoder_output.data.topk(1) # 1개의 가장 큰 요소를 반환
+            if top_index.item() == EOS_token:
+                decoded_words.append("<EOS>")
+                break
+            else:
+                decoded_words.append(target_vocab.index2vocab[top_index.item()])
+
+            decoder_input = top_index.squeeze().detach()
+
+        predict_words = decoded_words
+        predict_sentence = " ".join(predict_words)
+        print("<", predict_sentence)
+        print("")
+```
+
+data를 tensor로 만들어주고 학습했던 encoder와 decoder를 통과시켜 model이 에측한 문장을 출력한다.
+이때 decoder의 실제 출력은 softmax를 통해 나온 확률들이기 때문에 `topk(1)`로 가장 큰 값의 index를 받아 `Vocab`의 단어로 바꿔준다.
+
+```py
+evaluate(load_pairs, load_source_vocab, load_target_vocab, enc, dec, TARGET_MAX_LENGTH)
+
+'''output
+> i feel hungry.
+= 나는 배가 고프다.
+< 나는 배가 고프다. <EOS>
+
+> pytorch is very easy.
+= 파이토치는 매우 쉽다.
+< 파이토치는 매우 쉽다. <EOS>
+
+> pytorch is a framework for deep learning.
+= 파이토치는 딥러닝을 위한 프레임워크이다.
+< 파이토치는 딥러닝을 위한 프레임워크이다. <EOS>
+
+> pytorch is very clear to use.
+= 파이토치는 사용하기 매우 직관적이다.
+< 파이토치는 사용하기 매우 직관적이다. <EOS>
+'''
+```
+
+출력 결과 기존의 문장들에 대해 학습을 잘 한 것을 확인할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-06-13-boj_1009.markdown b/_posts/2022-06-13-boj_1009.markdown
new file mode 100644
index 00000000000..b5a55fe84a9
--- /dev/null
+++ b/_posts/2022-06-13-boj_1009.markdown
@@ -0,0 +1,107 @@
+---
+title: "[BOJ] 분산 처리 - 1009 (B2)"
+author: kwon
+date: 2022-06-13T23:00:00 +0900
+categories: [boj, bronze]
+tags: [math, implementation]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1 초 | 128 MB |
+
+# 문제
+
+재용이는 최신 컴퓨터 10대를 가지고 있다. 어느 날 재용이는 많은 데이터를 처리해야 될 일이 생겨서 각 컴퓨터에 1번부터 10번까지의 번호를 부여하고, 10대의 컴퓨터가 다음과 같은 방법으로 데이터들을 처리하기로 하였다.
+
+1번 데이터는 1번 컴퓨터, 2번 데이터는 2번 컴퓨터, 3번 데이터는 3번 컴퓨터, ... ,
+
+10번 데이터는 10번 컴퓨터, 11번 데이터는 1번 컴퓨터, 12번 데이터는 2번 컴퓨터, ...
+
+총 데이터의 개수는 항상 $a^b$개의 형태로 주어진다. 재용이는 문득 마지막 데이터가 처리될 컴퓨터의 번호가 궁금해졌다. 이를 수행해주는 프로그램을 작성하라.
+
+# 입력
+
+입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트 케이스에 대해 정수 a와 b가 주어진다. (1 ≤ a < 100, 1 ≤ b < 1,000,000)
+
+# 출력
+
+각 테스트 케이스에 대해 마지막 데이터가 처리되는 컴퓨터의 번호를 출력한다.
+
+# 풀이
+
+주어진 숫자는 제곱의 형태로 주어지며 최대 $1000000^{100}$이 될 수 있기 때문에 컴퓨터로 처리하는 것을 모두 시뮬레이션하는 것으로는 시간 제한을 맞출 수 없다. 모두 확인하지 않고 어떤 컴퓨터가 처리했는지 알 수 있는 방법은 주어진 숫자의 1의 자리를 활용하는 것이다. 어떤 1의 자리의 수를 n번 곱하면 계산된 수의 1의 자리가 주기적으로 반복되는 것을 알 수 있고 그 수는 아래와 같이 나타낼 수 있다.
+
+```python
+nums = {1 : [1],
+        2 : [2, 4, 8, 6],
+        3 : [3, 9, 7, 1],
+        4 : [4, 6],
+        5 : [5],
+        6 : [6],
+        7 : [7, 9, 3, 1],
+        8 : [8, 4, 2, 6],
+        9 : [9, 1]}
+```
+
+하지만 무턱대고 $a^b$를 계산해서 1의 자리를 구한다고 해도 중복되는 값들이 있기 때문에 정확히 어떤 수의 제곱인지 알 수 없다. 그래서 먼저 a를 nums의 키로 넣어 제곱 했을 때 1의 자리에 나올 값들을  추려내고 그 중 b번째 값을 답으로 출력한다. b번째 값이 답이 될 수 있는 이유는 a를 b번 곱하는 동안에 1의 자리의 값도 b번 바뀔 것이기 때문이다.
+
+예를 들어 a가 124, b가 16이라고 하면 다음과 같은 과정을 거치게 된다.
+
+```python
+n = int(input())
+
+nums = {1 : [1],
+        2 : [2, 4, 8, 6],
+        3 : [3, 9, 7, 1],
+        4 : [4, 6],
+        5 : [5],
+        6 : [6],
+        7 : [7, 9, 3, 1],
+        8 : [8, 4, 2, 6],
+        9 : [9, 1]}
+
+for _ in range(n):
+    a, b = map(int, input().split())
+    # a의 1의 자리수를 구한다 -> 4
+		one = a % 10
+
+		# 1의 자리에 나올 수 있는 값들을 가져온다 -> nums[4] -> [4, 6]
+		# 이 중에서 b번째 값을 취한다. 4, 6, 4, 6, 4, 6 -> 6
+    print(nums[one][(b - 1) % len(nums[one])])
+```
+
+단 a의 1의 자리가 0일 경우 무조건 제곱한 수의 1의 자리도 0이므로 10번 컴퓨터가 처리하게 된다.
+
+```python
+a, b = map(int, input().split())
+one = a % 10
+if  not one:
+    print(10)
+```
+
+## 코드
+
+```python
+n = int(input())
+
+nums = {1 : [1],
+        2 : [2, 4, 8, 6],
+        3 : [3, 9, 7, 1],
+        4 : [4, 6],
+        5 : [5],
+        6 : [6],
+        7 : [7, 9, 3, 1],
+        8 : [8, 4, 2, 6],
+        9 : [9, 1]}
+
+for _ in range(n):
+    a, b = map(int, input().split())
+    one = a % 10
+    if  not one:
+        print(10)
+    else:
+        print(nums[one][(b - 1) % len(nums[one])])
+```
\ No newline at end of file
diff --git a/_posts/2022-09-06-boj_1406.markdown b/_posts/2022-09-06-boj_1406.markdown
new file mode 100644
index 00000000000..2438b7f8ca9
--- /dev/null
+++ b/_posts/2022-09-06-boj_1406.markdown
@@ -0,0 +1,86 @@
+---
+title: "[BOJ] 에디터 - 1406 (S2)
+)"
+author: kwon
+date: 2022-9-6T14:00:00 +0900
+categories: [boj, silver]
+tags: [data structure, stack, linked list]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 0.3 | 512 |
+
+# 문제
+
+한 줄로 된 간단한 에디터를 구현하려고 한다. 이 편집기는 영어 소문자만을 기록할 수 있는 편집기로, 최대 600,000글자까지 입력할 수 있다.
+
+이 편집기에는 '커서'라는 것이 있는데, 커서는 문장의 맨 앞(첫 번째 문자의 왼쪽), 문장의 맨 뒤(마지막 문자의 오른쪽), 또는 문장 중간 임의의 곳(모든 연속된 두 문자 사이)에 위치할 수 있다. 즉 길이가 L인 문자열이 현재 편집기에 입력되어 있으면, 커서가 위치할 수 있는 곳은 L+1가지 경우가 있다.
+
+이 편집기가 지원하는 명령어는 다음과 같다.
+
+| L | 커서를 왼쪽으로 한 칸 옮김 (커서가 문장의 맨 앞이면 무시됨) |
+| --- | --- |
+| D | 커서를 오른쪽으로 한 칸 옮김 (커서가 문장의 맨 뒤이면 무시됨) |
+| B | 커서 왼쪽에 있는 문자를 삭제함 (커서가 문장의 맨 앞이면 무시됨)삭제로 인해 커서는 한 칸 왼쪽으로 이동한 것처럼 나타나지만, 실제로 커서의 오른쪽에 있던 문자는 그대로임 |
+| P $ | $라는 문자를 커서 왼쪽에 추가함 |
+
+초기에 편집기에 입력되어 있는 문자열이 주어지고, 그 이후 입력한 명령어가 차례로 주어졌을 때, 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 구하는 프로그램을 작성하시오. 단, 명령어가 수행되기 전에 커서는 문장의 맨 뒤에 위치하고 있다고 한다.
+
+# 입력
+
+첫째 줄에는 초기에 편집기에 입력되어 있는 문자열이 주어진다. 이 문자열은 길이가 N이고, 영어 소문자로만 이루어져 있으며, 길이는 100,000을 넘지 않는다. 둘째 줄에는 입력할 명령어의 개수를 나타내는 정수 M(1 ≤ M ≤ 500,000)이 주어진다. 셋째 줄부터 M개의 줄에 걸쳐 입력할 명령어가 순서대로 주어진다. 명령어는 위의 네 가지 중 하나의 형태로만 주어진다.
+
+# 출력
+
+첫째 줄에 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 출력한다.
+
+# 풀이
+
+커서를 움직이거나 기준으로 문자를 삭제/추가하는 명령을 수행해야 한다. 이를 위해 커서를 인덱스 값으로 두고 구현할 수도 있겠지만 stack의 관점으로 본다면 조금 더 편하게 문제를 해결할 수 있다.
+
+![](/posting_imgs/boj_1406-1.png)
+
+위 그림과 같이 커서를 중심으로 양 쪽의 문자열들을 스택으로 생각하면 문제에서 주어진 4 개의 명령어를 수행하기 편해진다. 단, 여기서 스택의 가장 위를 커서가 있는 방향으로 생각한다. 즉, 왼쪽 스택은 오른쪽이 스택의 위쪽이며 오른쪽 스택은 왼쪽이 스택의 위쪽이 된다.
+
+먼저, 커서를 옮기는 경우에는 한 쪽의 스택의 가장 위에 있는 문자열을 반대쪽 스택으로 넣어주면 된다. 
+
+![](/posting_imgs/boj_1406-2.png)
+
+예를 들어 **D** 명령을 통해 커서를 오른쪽으로 옮길 때 위 그림처럼 오른쪽 스택의 가장 위에 있는 f를 빼서 왼쪽 스택으로 넣어주면 커서를 오른쪽으로 움직이는 것과 같은 효과를 볼 수 있다.
+
+삭제 명령은 커서가 맨 앞에 있는 경우를 제외하면 항상 왼쪽 스택의 문자를 하나씩 삭제하면 되며, 삽입 명령은 항상 왼쪽 스택에 삽입하려는 문자를 넣어주면 된다.
+
+## 코드
+
+```python
+import sys
+
+input = sys.stdin.readline
+
+left = list(input().rstrip())
+right = []
+
+for _ in range(int(input())):
+    com = (list(input().split()))
+    if com[0] == 'L':
+        if left:
+            right.append(left.pop())
+            
+    elif com[0] == 'D':
+        if right:
+            left.append(right.pop())
+            
+    elif com[0] == 'B':
+        if left:
+            left.pop()
+            
+    elif com[0] == 'P':
+        left.append(com[1])
+
+print(''.join(left+right[::-1]))
+```
+
+python에서는 list의 `pop()` 함수로 스택에서 꺼내고, `append()` 함수로 스택에 값을 넣는 것으로 stack을 간단하게 구현할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-09-13-boj_24060.markdown b/_posts/2022-09-13-boj_24060.markdown
new file mode 100644
index 00000000000..951c689ad4f
--- /dev/null
+++ b/_posts/2022-09-13-boj_24060.markdown
@@ -0,0 +1,157 @@
+---
+title: "[BOJ] 병합 정렬 1 - 24060 (S3)"
+author: kwon
+date: 2022-09-13T23:00:00 +0900
+categories: [boj, silver]
+tags: [implementation, sort, recursion]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1 초 | 512 MB |
+
+## 문제
+
+오늘도 서준이는 병합 정렬 수업 조교를 하고 있다. 아빠가 수업한 내용을 학생들이 잘 이해했는지 문제를 통해서 확인해보자.
+
+*N*개의 서로 다른 양의 정수가 저장된 배열 A가 있다. 병합 정렬로 배열 A를 오름차순 정렬할 경우 배열 A에 *K* 번째 저장되는 수를 구해서 우리 서준이를 도와주자.
+
+크기가 *N*인 배열에 대한 병합 정렬 의사 코드는 다음과 같다.
+
+```
+merge_sort(A[p..r]) { # A[p..r]을 오름차순 정렬한다.
+    if (p < r) then {
+        q <- ⌊(p + r) / 2⌋;       # q는 p, r의 중간 지점
+        merge_sort(A, p, q);      # 전반부 정렬
+        merge_sort(A, q + 1, r);  # 후반부 정렬
+        merge(A, p, q, r);        # 병합
+    }
+}
+
+# A[p..q]와 A[q+1..r]을 병합하여 A[p..r]을 오름차순 정렬된 상태로 만든다.
+# A[p..q]와 A[q+1..r]은 이미 오름차순으로 정렬되어 있다.
+merge(A[], p, q, r) {
+    i <- p; j <- q + 1; t <- 1;
+    while (i ≤ q and j ≤ r) {
+        if (A[i] ≤ A[j])
+        then tmp[t++] <- A[i++]; # tmp[t] <- A[i]; t++; i++;
+        else tmp[t++] <- A[j++]; # tmp[t] <- A[j]; t++; j++;
+    }
+    while (i ≤ q)  # 왼쪽 배열 부분이 남은 경우
+        tmp[t++] <- A[i++];
+    while (j ≤ r)  # 오른쪽 배열 부분이 남은 경우
+        tmp[t++] <- A[j++];
+    i <- p; t <- 1;
+    while (i ≤ r)  # 결과를 A[p..r]에 저장
+        A[i++] <- tmp[t++];
+}
+```
+
+## 입력
+
+첫째 줄에 배열 A의 크기 *N*(5 ≤ *N* ≤ 500,000), 저장 횟수 *K*(1 ≤ *K* ≤ 108)가 주어진다.
+
+다음 줄에 서로 다른 배열 A의 원소 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 109)
+
+## 출력
+
+배열 A에 *K* 번째 저장 되는 수를 출력한다. 저장 횟수가 *K* 보다 작으면 -1을 출력한다.
+
+# 풀이
+
+문제에 작성된 의사 코드를 따라 병합 정렬 코드를 완성하여 정렬된 배열 A에 K번째 저장된 수를 출력하는 문제이다.
+
+## 병합 정렬
+
+병합 정렬은 주어진 배열을 절반으로 나누는 과정과 이를 다시 합치는 병합 과정으로 진행된다.
+
+먼저 부분 배열(나누어진 배열)의 원소가 하나만 남거나 부분 배열이 빌 때까지 배열을 절반으로 나누어 준다. 이는 재귀를 이용하여 다음과 같이 구현할 수 있다.
+
+```python
+def merge_sort(a, p, r):
+    global result
+    if result != -1:
+        return
+    if p < r:
+        q = (p + r) // 2
+        merge_sort(a, p, q)
+        merge_sort(a, q+1, r)
+				...
+```
+
+모두 다 나눴으면 이제 병합하며 정렬된 배열을 완성한다.
+
+병합할 두 배열의 원소들을 확인하며 작은 순으로 배열에 넣어준다. 하지만 두 배열의 길이가 항상 같지는 않으므로 남은 배열의 원소들도 차례대로 넣어준다. 이 때 각 부분 배열들은 이전의 병합에서 이미 정렬된 상태이므로 그냥 순서대로 넣어주면 된다.
+
+위 방식대로 모든 병합을 완료하면 정렬이 완료된다.
+
+하지만 우리가 원하는 것은 특정 번째에 저장된 수를 찾는 것이므로 정렬한 값을 임시로 저장한 딕셔너리 `tmp`의 값을 배열 `a`에 옮겨주면서 원하는 번째에 `a`에 저장된 값을 찾아낸다.
+
+```python
+		...
+		while i <= r:
+        a[i] = tmp[t]
+        cnt += 1
+        if cnt == k:
+            cnt = -float('inf')
+            result = tmp[t]
+            return
+        t += 1
+        i += 1
+		...
+```
+
+## 코드
+
+```python
+a, k = map(int, input().split())
+nums = list(map(int, input().split()))
+cnt = 0
+result = -1
+def merge_sort(a, p, r):
+    global result
+    if result != -1:
+        return
+    if p < r:
+        q = (p + r) // 2
+        merge_sort(a, p, q)
+        merge_sort(a, q+1, r)
+        merge(a, p, q, r)
+
+def merge(a, p, q, r):
+    global cnt, result
+    i, j, t = p, q + 1, 0
+    tmp = {}
+    while i <= q and j <= r:
+        if a[i] <= a[j]:
+            tmp[t] = a[i]
+            t += 1
+            i += 1
+        else: 
+            tmp[t] = a[j]
+            t += 1
+            j += 1
+    while i <= q:
+        tmp[t] = a[i]
+        t += 1
+        i += 1
+    while j <= r:
+        tmp[t] = a[j]
+        t += 1
+        j += 1
+    i, t = p, 0
+    while i <= r:
+        a[i] = tmp[t]
+        cnt += 1
+        if cnt == k:
+            cnt = -float('inf')
+            result = tmp[t]
+            return
+        t += 1
+        i += 1
+
+merge_sort(nums, 0, a-1)
+print(result)
+```
\ No newline at end of file
diff --git a/_posts/2022-09-26-boj_7568.markdown b/_posts/2022-09-26-boj_7568.markdown
new file mode 100644
index 00000000000..dd48028a258
--- /dev/null
+++ b/_posts/2022-09-26-boj_7568.markdown
@@ -0,0 +1,60 @@
+---
+title: "[BOJ] 덩치 - 7568 (S5)"
+author: kwon
+date: 2022-09-26T23:00:00 +0900
+categories: [boj, silver]
+tags: [implementation, brute-force]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1초 | 128 MB |
+
+# 문제
+
+우리는 사람의 덩치를 키와 몸무게, 이 두 개의 값으로 표현하여 그 등수를 매겨보려고 한다. 어떤 사람의 몸무게가 x kg이고 키가 y cm라면 이 사람의 덩치는 (x, y)로 표시된다. 두 사람 A 와 B의 덩치가 각각 (x, y), (p, q)라고 할 때 x > p 그리고 y > q 이라면 우리는 A의 덩치가 B의 덩치보다 "더 크다"고 말한다. 예를 들어 어떤 A, B 두 사람의 덩치가 각각 (56, 177), (45, 165) 라고 한다면 A의 덩치가 B보다 큰 셈이 된다. 그런데 서로 다른 덩치끼리 크기를 정할 수 없는 경우도 있다. 예를 들어 두 사람 C와 D의 덩치가 각각 (45, 181), (55, 173)이라면 몸무게는 D가 C보다 더 무겁고, 키는 C가 더 크므로, "덩치"로만 볼 때 C와 D는 누구도 상대방보다 더 크다고 말할 수 없다.
+
+N명의 집단에서 각 사람의 덩치 등수는 자신보다 더 "큰 덩치"의 사람의 수로 정해진다. 만일 자신보다 더 큰 덩치의 사람이 k명이라면 그 사람의 덩치 등수는 k+1이 된다. 이렇게 등수를 결정하면 같은 덩치 등수를 가진 사람은 여러 명도 가능하다. 아래는 5명으로 이루어진 집단에서 각 사람의 덩치와 그 등수가 표시된 표이다.
+
+| 이름 | (몸무게, 키) | 덩치 등수 |
+| --- | --- | --- |
+| A | (55, 185) | 2 |
+| B | (58, 183) | 2 |
+| C | (88, 186) | 1 |
+| D | (60, 175) | 2 |
+| E | (46, 155) | 5 |
+
+위 표에서 C보다 더 큰 덩치의 사람이 없으므로 C는 1등이 된다. 그리고 A, B, D 각각의 덩치보다 큰 사람은 C뿐이므로 이들은 모두 2등이 된다. 그리고 E보다 큰 덩치는 A, B, C, D 이렇게 4명이므로 E의 덩치는 5등이 된다. 위 경우에 3등과 4등은 존재하지 않는다. 여러분은 학생 N명의 몸무게와 키가 담긴 입력을 읽어서 각 사람의 덩치 등수를 계산하여 출력해야 한다.
+
+# 입력
+
+첫 줄에는 전체 사람의 수 N이 주어진다. 그리고 이어지는 N개의 줄에는 각 사람의 몸무게와 키를 나타내는 양의 정수 x와 y가 하나의 공백을 두고 각각 나타난다.
+
+# 출력
+
+여러분은 입력에 나열된 사람의 덩치 등수를 구해서 그 순서대로 첫 줄에 출력해야 한다. 단, 각 덩치 등수는 공백문자로 분리되어야 한다.
+
+# 풀이
+
+모든 사람들을 비교하면서 키와 몸무게가 둘 다 작을 경우 해당 사람의 인덱스에 카운트를 하나 올린다 (등수를 하나 내림). 마지막에 카운트한 배열을 출력한다. 등수는 1등부터 시작하기 때문에 등수(카운트)를 저장하는 배열의 값은 1로 정의하고 시작한다.
+
+## 코드
+
+```python
+n = int(input())
+l = []
+cnt = [1] * n
+for _ in range(n):
+    l.append(tuple(map(int, input().split())))
+
+for i in range(n):
+    for j in range(i+1, n):
+        p1, p2 = l[i], l[j]
+        if p1[0] > p2[0] and p1[1] > p2[1]:
+            cnt[j] += 1
+        elif p1[0] < p2[0] and p1[1] < p2[1]:
+            cnt[i] += 1
+print(' '.join(map(str, cnt)))
+```
\ No newline at end of file
diff --git a/_posts/2022-10-04-boj_1269.markdown b/_posts/2022-10-04-boj_1269.markdown
new file mode 100644
index 00000000000..9c064dba57a
--- /dev/null
+++ b/_posts/2022-10-04-boj_1269.markdown
@@ -0,0 +1,42 @@
+---
+title: "[BOJ] 대칭 차집합 - 1269 (S4)"
+author: kwon
+date: 2022-10-4T14:00:00 +0900
+categories: [boj, silver]
+tags: [data structure, set / map by hashing, set / map by tree]
+math: true
+mermaid: false
+---
+
+22/10/4
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 256 MB |
+
+# 문제
+
+자연수를 원소로 갖는 공집합이 아닌 두 집합 A와 B가 있다. 이때, 두 집합의 대칭 차집합의 원소의 개수를 출력하는 프로그램을 작성하시오. 두 집합 A와 B가 있을 때, (A-B)와 (B-A)의 합집합을 A와 B의 대칭 차집합이라고 한다.
+
+예를 들어, A = { 1, 2, 4 } 이고, B = { 2, 3, 4, 5, 6 } 라고 할 때,  A-B = { 1 } 이고, B-A = { 3, 5, 6 } 이므로, 대칭 차집합의 원소의 개수는 1 + 3 = 4개이다.
+
+# 입력
+
+첫째 줄에 집합 A의 원소의 개수와 집합 B의 원소의 개수가 빈 칸을 사이에 두고 주어진다. 둘째 줄에는 집합 A의 모든 원소가, 셋째 줄에는 집합 B의 모든 원소가 빈 칸을 사이에 두고 각각 주어진다. 각 집합의 원소의 개수는 200,000을 넘지 않으며, 모든 원소의 값은 100,000,000을 넘지 않는다.
+
+# 출력
+
+첫째 줄에 대칭 차집합의 원소의 개수를 출력한다.
+
+# 풀이
+
+대칭 차집합의 정의에 따라 그대로 코드로 작성하면 되는 문제다. 대칭 차집합의 각 차집합 (A-B)와 (B-A)는 교집합이 무조건 공집합이므로 각 차집합의 원소 개수를 더하는 것으로 대칭 차집합의 원소 개수를 구할 수 있다.
+
+## 코드
+
+```python
+input()
+a = set(map(int, input().split()))
+b = set(map(int, input().split()))
+print(len(a - b) + len(b - a))
+```
\ No newline at end of file
diff --git a/_posts/2022-10-11-boj_10989.markdown b/_posts/2022-10-11-boj_10989.markdown
new file mode 100644
index 00000000000..25c8643bda4
--- /dev/null
+++ b/_posts/2022-10-11-boj_10989.markdown
@@ -0,0 +1,49 @@
+---
+title: "[BOJ] 수 정렬하기 3 - 10989 (B1)"
+author: kwon
+date: 2022-10-11T23:00:00 +0900
+categories: [boj, bronze]
+tags: [sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 512 MB |
+
+# 문제
+
+N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.
+
+# 입력
+
+첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 수가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.
+
+# 출력
+
+첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.
+
+# 풀이
+
+중복된 수를 여러번 정렬하는 것을 피하기 위해 딕셔너리에 숫자 : 개수 형태로 저장한 뒤에 key를 정렬하여 수의 개수만큼 그 수(key)를 출력해준다.
+
+## 코드
+
+```python
+import sys
+from collections import defaultdict
+input = sys.stdin.readline
+print = sys.stdout.write
+
+n = int(input())
+nums = []
+d = defaultdict(int)
+
+for _ in range(n):
+    d[int(input())] += 1
+
+for num in sorted(d):
+    for _ in range(d[num]):
+        print(f'{str(num)}\n')
+```
\ No newline at end of file
diff --git a/_posts/2022-10-13-boj_11650-11651.markdown b/_posts/2022-10-13-boj_11650-11651.markdown
new file mode 100644
index 00000000000..3128389e92a
--- /dev/null
+++ b/_posts/2022-10-13-boj_11650-11651.markdown
@@ -0,0 +1,83 @@
+---
+title: "[BOJ] 좌표 정렬 1, 2 - 11650, 11651 (S5)"
+author: kwon
+date: 2022-10-13T23:00:00 +0900
+categories: [boj, silver]
+tags: [sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 256 MB |
+
+# 문제
+
+좌표 정렬하기 1: 2차원 평면 위의 점 N개가 주어진다. 좌표를 x좌표가 증가하는 순으로, x좌표가 같으면 y좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.
+
+좌표 정렬하기 2: 2차원 평면 위의 점 N개가 주어진다. 좌표를 y좌표가 증가하는 순으로, y좌표가 같으면 x좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.
+
+# 입력
+
+첫째 줄에 점의 개수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N개의 줄에는 i번점의 위치 xi와 yi가 주어진다. (-100,000 ≤ xi, yi ≤ 100,000) 좌표는 항상 정수이고, 위치가 같은 두 점은 없다.
+
+# 출력
+
+첫째 줄부터 N개의 줄에 점을 정렬한 결과를 출력한다.
+
+# 풀이
+
+1, 2 모두 주어진  좌표를 정렬하는 문제이다. 다른 점은 1은 x좌표를 우선으로, 2는 y좌표를 우선으로 정렬한다는 것이다.  주어진 입력의 x, y 값의 범위가 (-100,000 ≤ xi, yi ≤ 100,000)로 제한적이고 정수이기 때문에 Counting Sort를 사용하기에 적합하다.
+
+수의 개수를 세어줄 배열의 크기를 x, y의 범위에 맞게 200,002로 잡아준다. 200,001로 크기를 잡지 않은 이유는 깔끔하게 100,000을 더해서 인덱스가 헷갈리지 않게 코드를 작성할 수 있기 때문이다.
+
+메모리를 적게 써서 공간복잡도를 줄이는 것도 중요하지만, 이 문제와 같이 충분한 메모리가 주어진 상황에서는 배열 한 자리의 메모리를 줄이는 것보다 헷갈리는 부분을 없애버리고 가독성을 높여 거기서 발생할 수 있는 실수를 줄이는  것이 이득이라고 판단했다.
+
+하나의 수열을 정렬하는 경우에는 주어진 수의 개수만 저장하면 되겠지만 좌표를 정렬하는 경우에는 우선순위가 아닌 수들(1번 문제의 경우 y좌표)도 신경써야하기 때문에 해당하는 x좌표에 y좌표의 배열을 저장해주었다.
+
+이렇게 배열을 만들게 되면 x좌표의 크기에 따라 y좌표의 배열들이 저장되므로 y좌표가 저장된 경우에만 정렬하여 좌표를 출력하면 된다.
+
+## 코드
+
+```python
+import sys
+input = sys.stdin.readline
+print = sys.stdout.write
+
+n = int(input())
+cnt_list = [[] for i in range(200002)]
+for _ in range(n):
+    x, y = map(int, input().split())
+    cnt_list[x + 100000].append(y)
+
+for x, ys in enumerate(cnt_list):
+    if ys:
+        if len(ys) == 1:
+            print(f"{x - 100000} {ys[0]}\n")
+        else:
+            for y in sorted(ys):
+                print(f"{x - 100000} {y}\n")
+```
+
+2번 문제도 마찬가지로 진행하되 y를 기준으로 배열을 만들어 x좌표를 append해준다.
+
+```python
+import sys
+input = sys.stdin.readline
+print = sys.stdout.write
+
+n = int(input())
+cnt_list = [[] for i in range(200002)]
+for _ in range(n):
+    x, y = map(int, input().split())
+    cnt_list[y + 100000].append(x)
+
+for y, xs in enumerate(cnt_list):
+    if xs:
+        if len(xs) == 1:
+            print(f"{xs[0]} {y - 100000}\n")
+        else:
+            for x in sorted(xs):
+                print(f"{x} {y - 100000}\n")
+```
\ No newline at end of file
diff --git a/_posts/2022-10-13-boj_1181.markdown b/_posts/2022-10-13-boj_1181.markdown
new file mode 100644
index 00000000000..3c963dc4b00
--- /dev/null
+++ b/_posts/2022-10-13-boj_1181.markdown
@@ -0,0 +1,56 @@
+---
+title: "[BOJ] 단어 정렬 - 1181 (S5)"
+author: kwon
+date: 2022-10-13T23:00:00 +0900
+categories: [boj, silver]
+tags: [string, sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 256 MB |
+
+# 문제
+
+알파벳 소문자로 이루어진 N개의 단어가 들어오면 아래와 같은 조건에 따라 정렬하는 프로그램을 작성하시오.
+
+1. 길이가 짧은 것부터
+2. 길이가 같으면 사전 순으로
+
+# 입력
+
+첫째 줄에 단어의 개수 N이 주어진다. (1 ≤ N ≤ 20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주어지는 문자열의 길이는 50을 넘지 않는다.
+
+# 출력
+
+조건에 따라 정렬하여 단어들을 출력한다. 단, 같은 단어가 여러 번 입력된 경우에는 한 번씩만 출력한다.
+
+# 풀이
+
+입력된 단어의 길이를 index로 해당 길이의 단어 묶음을 원소로 하는 리스트를 만들어 준다. 이 때 단어는 중복을 허용하지 않기 때문에 묶음을 집합으로 만들어 준다.
+
+이후 리스트를 반복하면서 단어가 존재하는 경우 단어들을 출력해 준다. 단어가 여러 개면 list로 바꿔(set은 순서가 없다) 정렬한 것을 차례대로 출력해 준다.
+
+## 코드
+
+```python
+import sys
+input = sys.stdin.readline
+print = sys.stdout.write
+
+n = int(input())
+len_cnt = [set() for i in range(51)]
+for _ in range(n):
+    word = input().strip()
+    len_cnt[len(word)].add(word)
+
+for words in len_cnt:
+    if words:
+        if len(words) == 1:
+            print(f"{list(words)[0]}\n")
+        else:
+            for w in sorted(list(words)):
+                print(f"{w}\n")
+```
\ No newline at end of file
diff --git a/_posts/2022-10-13-boj_1427.markdown b/_posts/2022-10-13-boj_1427.markdown
new file mode 100644
index 00000000000..c23d387ec30
--- /dev/null
+++ b/_posts/2022-10-13-boj_1427.markdown
@@ -0,0 +1,49 @@
+---
+title: "[BOJ] 소트 인사이드 - 1427 (S5)"
+author: kwon
+date: 2022-10-13T14:00:00 +0900
+categories: [boj, silver]
+tags: [string, sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 128 MB |
+
+# 문제
+
+배열을 정렬하는 것은 쉽다. 수가 주어지면, 그 수의 각 자리수를 내림차순으로 정렬해보자.
+
+# 입력
+
+첫째 줄에 정렬하려고 하는 수 N이 주어진다. N은 1,000,000,000보다 작거나 같은 자연수이다.
+
+# 출력
+
+첫째 줄에 자리수를 내림차순으로 정렬한 수를 출력한다.
+
+# 풀이
+
+주어진 수를 내림차순 정렬하는 간단한 문제이다. 정수로 수열이 이루어져 있기 때문에 counting sort를 사용하여 풀었다.
+
+## 코드
+
+```python
+import sys
+input = sys.stdin.readline
+
+num = input().strip()
+cnt_dict = {str(n):0 for n in range(9, -1, -1)}
+for i in num:
+    cnt_dict[i] += 1
+ans = ''
+for i in cnt_dict:
+    for _ in range(cnt_dict[i]):
+        ans += i
+
+print(ans)
+```
+
+9~0까지의 수를 key로 가지고 value가 0인 dictionary를 만들고 수가 얼마나 나왔는지 count 한다. 이후 dictionary의 key 순서대로(내림차순) count 된 수만큼 문자를 붙여가며 답을 완성한다.
\ No newline at end of file
diff --git a/_posts/2022-11-15-boj_1004.markdown b/_posts/2022-11-15-boj_1004.markdown
new file mode 100644
index 00000000000..c700437db3c
--- /dev/null
+++ b/_posts/2022-11-15-boj_1004.markdown
@@ -0,0 +1,66 @@
+---
+title: "[BOJ] 어린 왕자 - 1004 (S3)"
+author: kwon
+date: 2022-11-15T23:00:00 +0900
+categories: [boj, silver]
+tags: [math, geometry]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 128 MB |
+
+# 문제
+
+어린 왕자는 소혹성 B-664에서 자신이 사랑하는 한 송이 장미를 위해 살아간다. 어느 날 장미가 위험에 빠지게 된 것을 알게 된 어린 왕자는, 장미를 구하기 위해 은하수를 따라 긴 여행을 하기 시작했다. 하지만 어린 왕자의 우주선은 그렇게 좋지 않아서 행성계 간의 이동을 최대한 피해서 여행해야 한다. 아래의 그림은 어린 왕자가 펼쳐본 은하수 지도의 일부이다.
+
+!https://onlinejudgeimages.s3-ap-northeast-1.amazonaws.com/upload/201003/dfcmhrjj_113gw6bcng2_b.gif
+
+빨간 실선은 어린 왕자가 출발점에서 도착점까지 도달하는데 있어서 필요한 행성계 진입/이탈 횟수를 최소화하는 경로이며, 원은 행성계의 경계를 의미한다. 이러한 경로는 여러 개 존재할 수 있지만 적어도 3번의 행성계 진입/이탈이 필요하다는 것을 알 수 있다.
+
+위와 같은 은하수 지도, 출발점, 도착점이 주어졌을 때 어린 왕자에게 필요한 최소의 행성계 진입/이탈 횟수를 구하는 프로그램을 작성해 보자. 행성계의 경계가 맞닿거나 서로 교차하는 경우는 없다. 또한, 출발점이나 도착점이 행성계 경계에 걸쳐진 경우 역시 입력으로 주어지지 않는다.
+
+# 입력
+
+입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트케이스에 대해 첫째 줄에 출발점 $(x_1, y_1)$과 도착점 $(x_2, y_2)$이 주어진다. 두 번째 줄에는 행성계의 개수 n이 주어지며, 세 번째 줄부터 n줄에 걸쳐 행성계의 중점과 반지름 $(c_x, c_y, r)$이 주어진다.
+
+# 출력
+
+각 테스트 케이스에 대해 어린 왕자가 거쳐야 할 최소의 행성계 진입/이탈 횟수를 출력한다.
+
+# 제한
+
+- $1000 ≤ x_1, y_1, x_2, y_2, c_y, c_x ≤ 1000$
+- $1 ≤ r ≤ 1000$
+- $1 ≤ n ≤ 50$
+- 좌표와 반지름은 모두 정수
+
+# 풀이
+
+행성계를 꼭 통과해야 하는 조건을 먼저 찾는. 출발점이나 도착점이 행성계 안에 있을 경우 무조건 그 항성계를 통과해야 한다. 출발점이나 도착점을 포함하지 않고 있는 행성계는 어떻게든 피해갈 수 있기 때문이다.
+
+한 점이 원 안에 포함되어있는지 확인하려면, 원의 반지름과 원의 중심과 그 점 사이의 거리를 비교하면 된다. 원의 반지름이 더 크다면 그 점은 무조건 원 안에 위치하게 되고, 원의 중심과 그 점 사이의 거리를 비교하면 그 점은 원 밖에 위치하게 된다.
+
+## 코드
+
+```python
+t = int(input())
+for _ in range(t):
+    cnt = 0
+    x1, y1, x2, y2 = map(int, input().split())
+    n = int(input())
+    for _ in range(n):
+        c_x, c_y, r = map(int, input().split())
+        r = r ** 2
+        dis1 = (c_x - x1) ** 2 + (c_y - y1) ** 2
+        dis2 = (c_x - x2) ** 2 + (c_y - y2) ** 2
+        if (dis1 < r and dis2 < r) or (dis1 > r and dis2 > r):
+            continue
+        else:
+            cnt += 1
+    print(cnt)
+```
+
+두 점 사이의 거리는 x, y 좌표 간의 차이의 제곱의 합에 제곱근을 취해 구할 수 있다. 위 코드에서는 연산을 조금 줄이기 위해 제곱인 상태에서 크기를 비교한다. 이 방법으로 출발점과 도착점을 포함하는 원들의 개수를 구해서 출력한다.
\ No newline at end of file
diff --git a/_posts/2022-11-15-boj_1037.markdown b/_posts/2022-11-15-boj_1037.markdown
new file mode 100644
index 00000000000..2d4de94d030
--- /dev/null
+++ b/_posts/2022-11-15-boj_1037.markdown
@@ -0,0 +1,43 @@
+---
+title: "[BOJ] 약수 - 1037 (B1)"
+author: kwon
+date: 2022-11-15T23:00:00 +0900
+categories: [boj, bronze]
+tags: [math, number theory]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 512 MB |
+
+# 문제
+
+양수 A가 N의 진짜 약수가 되려면, N이 A의 배수이고, A가 1과 N이 아니어야 한다. 어떤 수 N의 진짜 약수가 모두 주어질 때, N을 구하는 프로그램을 작성하시오.
+
+# 입력
+
+첫째 줄에 N의 진짜 약수의 개수가 주어진다. 이 개수는 50보다 작거나 같은 자연수이다. 둘째 줄에는 N의 진짜 약수가 주어진다. 1,000,000보다 작거나 같고, 2보다 크거나 같은 자연수이고, 중복되지 않는다.
+
+# 출력
+
+첫째 줄에 N을 출력한다. N은 항상 32비트 부호있는 정수로 표현할 수 있다.sㄴ
+
+# 풀이
+
+주어지는 A가 약수이므로 이들을 모두를 약수로 가지는 수 N를 구하기 위해서 굳이 모든 A를 확인하며 계산할 필요는 없다. 곱했을 때 N이 되도록 하는 약수들의 쌍을 찾아내기만 하면 되기 때문이다.
+
+내가 생각했을 때 가장 쉬운 방법은 주어진 약수들 중 최소값과 최대값을 찾아 곱하는 것이다. 모든 약수들 중에서 최소와 최대로 만든 쌍은 곱했을 때 항상 이 약수들을 포함하는 수가 된다.
+
+## 코드
+
+```python
+n = int(input())
+div = list(map(int, input().split()))
+min, max = float('inf'), float('-inf')
+for d in div:
+    if min > d : min = d
+    if max < d : max = d
+print(min * max)
+```
\ No newline at end of file
diff --git a/_posts/2022-11-22-boj_1010.markdown b/_posts/2022-11-22-boj_1010.markdown
new file mode 100644
index 00000000000..d9955dbb9f9
--- /dev/null
+++ b/_posts/2022-11-22-boj_1010.markdown
@@ -0,0 +1,71 @@
+---
+title: "[BOJ] 다리 놓기 - 1010 (S5)"
+author: kwon
+date: 2022-11-22T23:00:00 +0900
+categories: [boj, silver]
+tags: [math, dynamic programing, combinatorics]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 0.5 초 (추가 시간 없음) | 128 MB |
+
+# 문제
+
+재원이는 한 도시의 시장이 되었다. 이 도시에는 도시를 동쪽과 서쪽으로 나누는 큰 일직선 모양의 강이 흐르고 있다. 하지만 재원이는 다리가 없어서 시민들이 강을 건너는데 큰 불편을 겪고 있음을 알고 다리를 짓기로 결심하였다. 강 주변에서 다리를 짓기에 적합한 곳을 사이트라고 한다. 재원이는 강 주변을 면밀히 조사해 본 결과 강의 서쪽에는 N개의 사이트가 있고 동쪽에는 M개의 사이트가 있다는 것을 알았다. (N ≤ M)
+
+재원이는 서쪽의 사이트와 동쪽의 사이트를 다리로 연결하려고 한다. (이때 한 사이트에는 최대 한 개의 다리만 연결될 수 있다.) 재원이는 다리를 최대한 많이 지으려고 하기 때문에 서쪽의 사이트 개수만큼 (N개) 다리를 지으려고 한다. 다리끼리는 서로 겹쳐질 수 없다고 할 때 다리를 지을 수 있는 경우의 수를 구하는 프로그램을 작성하라.
+
+![https://www.acmicpc.net/upload/201003/pic1.JPG](https://www.acmicpc.net/upload/201003/pic1.JPG)
+
+# 입력
+
+입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트 케이스에 대해 강의 서쪽과 동쪽에 있는 사이트의 개수 정수 N, M (0 < N ≤ M < 30)이 주어진다.
+
+# 출력
+
+각 테스트 케이스에 대해 주어진 조건 하에 다리를 지을 수 있는 경우의 수를 출력한다.
+
+# 풀이
+
+## 조합
+
+서쪽의 다리의 개수만큼 동쪽의 다리를 고르는 문제로 생각할 수 있다. 하지만 주의할 점은 다리가 교차되면 안된다는 것이다. 때문에 순서를 생각하지 않고 서쪽의 다리를 동쪽 다리 개수만큼 골라야 한다.
+
+순서 없이 M개를 고른 후 서쪽 다리의 위부터, 고른 다리의 위부터 내려가면서 이어준다. 위부터 차례대로 이어주면  다리가 교차되는 일이 없고 순서는 딱 한 가지만 주어진다.
+
+그러므로 순서 없이 고르는 조합${m}\choose{n}$을 이용하면 된다.
+
+## 동적 프로그래밍
+
+다리를 이을 수 있는 쌍을 재귀로 반복하면서 개수를 찾는다. `b1`, `b2`는 각각 서-동쪽의 사이트 번호이며 `b1`이 N이 됐을 때 모든 다리가 이어진 것이므로 다리를 잇는 경우를 하나 찾았다는 의미로 1을 return한다.
+
+탐색은 위부터 시작하며 각 탐색의 범위는 직전에 연결했던 사이트의 다음(`b2+ 1`)부터 남은 서쪽 사이트 개수만큼 남을 때까지(`(b2 + 1) + m - n`)이다. 끝나는 범위가 앞선 식으로 계산되는 이유는 남아있는 서쪽 사이트가 연결될 수 있는 동쪽 사이트가 남아 있어야 하기 때문이다.
+
+예를 들어  n, m이 각각 4, 7이고 현재 연결하려는 사이트를 포함하여 남아있는 서쪽 사이트가 3개, 동쪽 사이트는 5 개라고 한다면, 현재 사이트를 연결하고 남아있는 동쪽 사이트가 최소 2 개는 되어야 하기 때문에 1 + (7 - 4) + 1 = 5로 동쪽의 5번째 사이트까지만 연결이 가능하다.
+
+### 코드
+
+```python
+def dp(b1, b2, n, m):
+    global memo
+    if b1 == n:
+        return 1
+    cnt = 0
+    for i in range(b2 + 1, min(m, b2 + m - n + 1) + 1):
+        if (b1 + 1, i) in memo:
+            cnt += memo[(b1 + 1, i)]
+        else:
+            tmp = dp(b1 + 1, i, n, m)
+            cnt += tmp
+            memo[(b1 + 1, i)] = tmp
+    return cnt
+
+t = int(input())
+for _ in range(t):
+    memo = {}
+    n, m = map(int, input().split())
+    print(dp(0, 0, n, m))
+```
\ No newline at end of file
diff --git a/_posts/2022-11-22-boj_3036.markdown b/_posts/2022-11-22-boj_3036.markdown
new file mode 100644
index 00000000000..56ab60b63a7
--- /dev/null
+++ b/_posts/2022-11-22-boj_3036.markdown
@@ -0,0 +1,79 @@
+---
+title: "[BOJ] 링 - 3036 (S4)"
+author: kwon
+date: 2022-11-22T23:00:00 +0900
+categories: [boj, silver]
+tags: [math, number theory, Euclidean algorithm]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1 초 | 128 MB |
+
+# 문제
+
+상근이는 창고에서 링 N개를 발견했다. 상근이는 각각의 링이 앞에 있는 링과 뒤에 있는 링과 접하도록 바닥에 내려놓았다.
+
+![](https://upload.acmicpc.net/44a0e81a-3870-4e94-8db0-73543fca3aa6/-/preview/)
+
+상근이는 첫 번째 링을 돌리기 시작했고, 나머지 링도 같이 돌아간다는 사실을 발견했다. 나머지 링은 첫 번째 링 보다 빠르게 돌아가기도 했고, 느리게 돌아가기도 했다. 이렇게 링을 돌리다 보니 첫 번째 링을 한 바퀴 돌리면, 나머지 링은 몇 바퀴 도는지 궁금해졌다.
+
+링의 반지름이 주어진다. 이때, 첫 번째 링을 한 바퀴 돌리면, 나머지 링은 몇 바퀴 돌아가는지 구하는 프로그램을 작성하시오.
+
+# 입력
+
+첫째 줄에 링의 개수 N이 주어진다. (3 ≤ N ≤ 100)
+
+다음 줄에는 링의 반지름이 상근이가 바닥에 놓은 순서대로 주어진다. 반지름은 1과 1000를 포함하는 사이의 자연수이다.
+
+# 출력
+
+출력은 총 N-1줄을 해야 한다. 첫 번째 링을 제외한 각각의 링에 대해서, 첫 번째 링을 한 바퀴 돌리면 그 링은 몇 바퀴 도는지 기약 분수 형태 A/B로 출력한다.
+
+# 풀이
+
+크게 3가지 경우가 존재하며 그에 대한 출력은 다음과 같다.
+
+1. 첫 번째 링의 크기를 링 하나의 크기로 나누었을 때 나누어 떨어지는 경우.
+    
+    `print(f"{first // r}/1")`
+    
+    첫 번째 링의 크기가 더 크며 배수 - 약수의 관계이므로 첫 번째 링을 현재 확인하고 있는 링의 크기로 나눈 몫을 분자로, 1을 분모로 하여 출력한다.
+    
+2. 링 하나의 크기를 첫 번째 링의 크기로 나누었을 때 나누어 떨어지는 경우.
+    
+    `print(f"1/{r // first}")`
+    
+    현재 링의 크기가 더 크며 배수 - 약수의 관계이므로 현재 링의 크기를 첫 번째 링의 크기로 나눈 몫을 분모로, 1을 분자로 하여 출력한다.
+    
+3. 둘 다 나누어 떨어지지 않는 경우
+    
+    이 경우 한 쪽의 값으로 나누어 떨어지지 않기 때문에 분자와 분모를 약분해야 한다. 약분은 각 수를 최대공약수로 나누면 구할 수 있다.
+    
+    최대 공약수는 [유클리드 호제법](/posts/euclidean_algorithm/)으로 구할 수 있다.
+    
+
+## 코드
+
+```python
+n = int(input())
+ring = list(map(int, input().split()))
+first = ring[0]
+rings = ring[1:]
+def gcd(a, b):
+    while a % b != 0:
+        r = a % b
+        a, b = b, r
+    return b
+
+for r in rings:
+    if first % r == 0:
+        print(f"{first // r}/1")
+    elif r % first == 0:
+        print(f"1/{r // first}")
+    else:
+        g = gcd(first, r)
+        print(f"{first // g}/{r // g}")
+```
\ No newline at end of file
diff --git a/_posts/2022-11-22-euclidean_algorithm.markdown b/_posts/2022-11-22-euclidean_algorithm.markdown
new file mode 100644
index 00000000000..e0511260413
--- /dev/null
+++ b/_posts/2022-11-22-euclidean_algorithm.markdown
@@ -0,0 +1,31 @@
+---
+title: "유클리드 호제법 (Euclidean algorithm)"
+author: kwon
+date: 2022-11-22T23:00:00 +0900
+categories: [background, math]
+tags: [math, number theory, Euclidean algorithm]
+math: true
+mermaid: false
+---
+
+유클리드 호제법은 2개의 자연수에 대해 최대공약수를 구하는 알고리즘이며 다음과 같은 성질을 통해 알고리즘을 진행한다.
+
+> $a, b \in \mathbb{Z}$이고 $a$를 $b$로 나눈 나머지를 $r$이라 하자. ($b \leq a, 0 \leq r \leq b$)
+> 
+> 
+> $a, b$의 최대 공약수를 $(a, b)$라고 하면, 다음이 성립한다.
+> 
+> $(a, b)=(b, r)$
+> 
+
+출처: wikipidia
+
+$r$이 0이 될 때 알고리즘을 멈추며, 이 때의 $b$가 최대공약수가 된다.
+
+예를 들어 1460과 1037에 대해 알고리즘을 진행해보면 다음과 같다.
+
+$$\begin{flalign*}
+(1460, 1037)\\=(1037, 323)\\=(323, 68)\\=(68, 52)\\=(52, 16)\\=(16, 4)\\=(4,0)
+\end{flalign*}$$
+
+$r$이 0일때 $b$가 4이므로 1460과 1037의 최대공약수는 4이다.
\ No newline at end of file
diff --git a/_posts/2022-12-12-boj_1541.markdown b/_posts/2022-12-12-boj_1541.markdown
new file mode 100644
index 00000000000..e81f3a7816c
--- /dev/null
+++ b/_posts/2022-12-12-boj_1541.markdown
@@ -0,0 +1,76 @@
+---
+title: "[BOJ] 잃어버린 괄호 - 1541 (S2)"
+author: kwon
+date: 2022-12-12T23:00:00 +0900
+categories: [boj, silver]
+tags: [math, string, greedy algorithm, parsing]
+math: true
+mermaid: false
+---
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2초 | 128 MB |
+
+## 문제
+
+세준이는 양수와 +, -, 그리고 괄호를 가지고 식을 만들었다. 그리고 나서 세준이는 괄호를 모두 지웠다.
+
+그리고 나서 세준이는 괄호를 적절히 쳐서 이 식의 값을 최소로 만들려고 한다.
+
+괄호를 적절히 쳐서 이 식의 값을 최소로 만드는 프로그램을 작성하시오.
+
+## 입력
+
+첫째 줄에 식이 주어진다. 식은 ‘0’~‘9’, ‘+’, 그리고 ‘-’만으로 이루어져 있고, 가장 처음과 마지막 문자는 숫자이다. 그리고 연속해서 두 개 이상의 연산자가 나타나지 않고, 5자리보다 많이 연속되는 숫자는 없다. 수는 0으로 시작할 수 있다. 입력으로 주어지는 식의 길이는 50보다 작거나 같다.
+
+## 출력
+
+첫째 줄에 정답을 출력한다.
+
+## 풀이
+
+입력되는 부호는 ‘+’, ‘-’ 뿐이기 때문에, 최소를 만들 수 있는 방법은 간단하게 구할 수 있다.
+
+‘-’가 등장하지 않으면 무조건 더할 수 밖에 없다.
+
+하지만 ‘-’가 등장하는 순간부터는 괄호를 이용하여 무조건 후에 나오는 수를 뺄셈으로 만들 수 있다.
+
+예를 들면 55-50+40+90-100+10-11 이라는 수식이 입력됐을 때 55-(50+40+90)-(100+10)-11 = 55-50-40-90-100-10-11 로 만들 수 있다.
+
+### 코드
+
+```python
+st = input().strip()+ '+'
+total = 0
+minus = False
+num = ''
+for c in st:
+    if c.isdigit():
+        num += c
+    else:
+        if minus:
+            total -= int(num)
+        else:
+            total += int(num)
+        if c == '-':
+            minus = True
+            
+        num = ''
+print(total)
+```
+
+입력은 숫자와 부호가 섞인 문자열로 주어지기 때문에 그 문자열을 확인하면서 문자가 숫자인지 부호인지에 때라 다르게 처리를 해주어야 한다.
+
+1. 숫자
+    
+    부호가 들어오기 전까지 하나의 숫자이기 때문에 문자열로 계속 이어준다.
+    
+2. +
+    
+    만약 ‘-’ 부호가 한 번도 나오지 않았다면 더할 수 밖에 없으므로 결과가 저장될 `total`에 정수로 이전까지 만들어 놓은 문자열을 정수로 바꿔 더한다.
+    
+3. -
+    
+    ‘-’가 등장한 순간부터는 무조건 빼면 되기 때문에 `minus` 변수를 `True`로 바꿔준다.
+    
+    이후의 연산은 `minus`가 `True`이기 때문에 이전까지 만들어 놓은 문자열을 정수로 바꿔 뺀다.
\ No newline at end of file
diff --git a/_posts/2022-12-12-boj_1931.markdown b/_posts/2022-12-12-boj_1931.markdown
new file mode 100644
index 00000000000..d9c71761cf8
--- /dev/null
+++ b/_posts/2022-12-12-boj_1931.markdown
@@ -0,0 +1,48 @@
+---
+title: "[BOJ] 회의실 배정 - 1931 (S1)"
+author: kwon
+date: 2022-12-12T23:00:00 +0900
+categories: [boj, silver]
+tags: [greedy algorithm, sort]
+math: true
+mermaid: false
+---
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2초 | 128 MB |
+
+# 문제
+한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.
+
+# 입력
+첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 $2^31-1$보다 작거나 같은 자연수 또는 0이다.
+
+# 출력
+첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.
+
+**끝나는 시간을 기준으로 먼저 정렬**하고 같으면 시작하는 시간을 기준으로 정렬하는 것이 핵심이다.
+
+이렇게 정렬을 하게 되면 항상 그 시간에 시작하는 회의 중 가장 빨리 끝나는 회의를 선택할 수 있으며, 끝나는 시간 이후에 시작하는 회의 중 가장 빨리 끝나는 회의도 바로 선택할 수 있다.
+
+## 코드
+
+```python
+n = int(input())
+meetings = []
+
+for _ in range(n):
+    s, f = map(int, input().split())
+    meetings.append((s, f))
+
+meetings.sort(key=lambda x: (x[1], x[0]))
+
+cur = 0
+cnt = 0
+for s, f in meetings:
+    if cur <= s:
+        cur = f
+        cnt += 1
+print(cnt)
+```
+
+앞서 말한 기준에 맞게 정렬을 하고 현재 선택한 회의가 끝나는 시간보다 더 늦게 시작하는 첫 회의를 선택하면 항상 최적의 선택을 할 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-12-13-boj_1946.markdown b/_posts/2022-12-13-boj_1946.markdown
new file mode 100644
index 00000000000..ed087ac6860
--- /dev/null
+++ b/_posts/2022-12-13-boj_1946.markdown
@@ -0,0 +1,125 @@
+---
+title: "[BOJ] 신입 사원 - 1946 (S1)"
+author: kwon
+date: 2022-12-13T23:00:00 +0900
+categories: [boj, silver]
+tags: [greedy algorithm, sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2초 | 256 MB |
+
+## 문제
+
+언제나 최고만을 지향하는 굴지의 대기업 진영 주식회사가 신규 사원 채용을 실시한다. 인재 선발 시험은 1차 서류심사와 2차 면접시험으로 이루어진다. 최고만을 지향한다는 기업의 이념에 따라 그들은 최고의 인재들만을 사원으로 선발하고 싶어 한다.
+
+그래서 진영 주식회사는, 다른 모든 지원자와 비교했을 때 서류심사 성적과 면접시험 성적 중 적어도 하나가 다른 지원자보다 떨어지지 않는 자만 선발한다는 원칙을 세웠다. 즉, 어떤 지원자 A의 성적이 다른 어떤 지원자 B의 성적에 비해 서류 심사 결과와 면접 성적이 모두 떨어진다면 A는 결코 선발되지 않는다.
+
+이러한 조건을 만족시키면서, 진영 주식회사가 이번 신규 사원 채용에서 선발할 수 있는 신입사원의 최대 인원수를 구하는 프로그램을 작성하시오.
+
+## 입력
+
+첫째 줄에는 테스트 케이스의 개수 T(1 ≤ T ≤ 20)가 주어진다. 각 테스트 케이스의 첫째 줄에 지원자의 숫자 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N개 줄에는 각각의 지원자의 서류심사 성적, 면접 성적의 순위가 공백을 사이에 두고 한 줄에 주어진다. 두 성적 순위는 모두 1위부터 N위까지 동석차 없이 결정된다고 가정한다.
+
+## 출력
+
+각 테스트 케이스에 대해서 진영 주식회사가 선발할 수 있는 신입사원의 최대 인원수를 한 줄에 하나씩 출력한다.
+
+## 풀이
+
+### 첫 시도
+
+범위가 정해져 있는 정수 데이터이기 때문에 conting sort를 변형하여 정렬을 하였고, 정렬된 배열을 기반으로 슬라이싱을 하여 set을 만들어서 풀이를 시도했다.
+
+```python
+import sys
+input = sys.stdin.readline
+t = int(input())
+
+for _ in range(t):
+    n = int(input())
+    p_cnt = [0] * (n + 1)
+    p_cnt2 = [0] * (n + 1)
+    for _ in range(n):
+        s1, s2 = map(int, input().split())
+        p_cnt[s1] = (s1, s2)
+        p_cnt2[s2] = (s1, s2)
+    top1 = p_cnt[1][1]
+    top2 = p_cnt2[1][0]
+
+    if p_cnt[1][1] == 1:
+        print(1)
+    else:
+        cnt = 0
+        set1 = set(p_cnt[1:top2 + 1])
+        set2 = set(p_cnt2[1:top1 + 1])
+        print(len(set1 & set2))
+```
+
+| 3 | 6 |
+| 7 | 3 |
+| 4 | 2 |
+| 1 | 4 |
+| 5 | 7 |
+| 2 | 5 |
+| 6 | 1 |
+
+위와 같은 예제가 있다고 생각해보자. 먼저 이를 성적과 면접 순으로 정렬한 리스트를 각각 만든다.
+
+| 1 | 4 |  | 6 | 1 |
+| 2 | 5 |  | 4 | 2 |
+| 3 | 6 |  | 7 | 3 |
+| 4 | 2 |  | 1 | 4 |
+| 5 | 7 |  | 2 | 5 |
+| 6 | 1 |  | 3 | 6 |
+| 7 | 3 |  | 5 | 7 |
+
+여기서 첫 번째 리스트(성적 순)는 면접 순위가 가장 높은 사람이 나올 때까지 슬라이싱을 하여 set으로 만들어 준다. set(p_cnt[1:top2 + 1])
+
+반대로 두 번째 리스트(면접 순)는 성적  순위가 가장 높은 사람이 나올 때까지 슬라이싱을 하여 set으로 만들어 준다. set2 = set(p_cnt2[1:top1 + 1])
+
+이렇게 만들면 각 set에 한 분야의 1 순위인 사람보다 다른 분야의 순위가 높은 사람들을 걸러낼 수 있고, 이 둘의 교집합을 이용하면 두 분야의 1 순위인 사람들보다 적어도 하나의 분야의 순위가 높은 사람들을 추려낼 수 있어서 정답을 구할 수 있다고 생각했다.
+
+실제로도 위 예제로 실행한 결과는 3으로 정상적으로 통과한다.
+
+하지만 아래의 예제와 같은 경우에는 문제가 발생한다.
+
+| 1 | 4 |
+| 2 | 2 |
+| 3 | 3 |
+| 4 | 1 |
+
+이 경우에는 위와 같은 방법으로 하게 되면 4명 모두 set에 들어가게 되므로 출력이 4가 나오게 된다.
+
+하지만 실제 정답은 (3, 3)이 (2, 2)에 막히게 되어 3 이 나와야 한다.
+
+### 수정한 코드
+
+```python
+import sys
+input = sys.stdin.readline
+
+t = int(input())
+
+for _ in range(t):
+    n = int(input())
+    p_cnt = [0] * (n + 1)
+    for _ in range(n):
+        s1, s2 = map(int, input().split())
+        p_cnt[s1] = (s1, s2)
+    
+    cnt = 1
+    best_s1, best_s2 = p_cnt[1]
+    for s1, s2 in p_cnt[2:]:
+        if best_s2 > s2:
+            cnt += 1
+            best_s2 = s2
+    print(cnt)
+```
+
+성적 순으로 정렬한 리스트 하나만 사용한다. 이 리스트를 돌면서 현재 저장되어 있는 면접 순위보다 높은 사람을 발견할 경우 카운트를 하나 늘리고 그 사람의 순위를 저장하여 반복문을 계속 진행한다. (초기 값은 성적 1위의 사람)
+
+이렇게 하면 성공적으로 어떤 사람보다 두 순위가 모두 낮은 사람을 걸러낼 수 있다.
\ No newline at end of file
diff --git a/_posts/2022-12-14-boj_1715.markdown b/_posts/2022-12-14-boj_1715.markdown
new file mode 100644
index 00000000000..a155680d06a
--- /dev/null
+++ b/_posts/2022-12-14-boj_1715.markdown
@@ -0,0 +1,62 @@
+---
+title: "[BOJ] 카드 정렬하기 - 1715 (G4)"
+author: kwon
+date: 2022-12-13T23:00:00 +0900
+categories: [boj, gold]
+tags: [data structure, greedy algorithm, priority queue]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2초 | 128 MB |
+
+## 문제
+
+정렬된 두 묶음의 숫자 카드가 있다고 하자. 각 묶음의 카드의 수를 A, B라 하면 보통 두 묶음을 합쳐서 하나로 만드는 데에는 A+B 번의 비교를 해야 한다. 이를테면, 20장의 숫자 카드 묶음과 30장의 숫자 카드 묶음을 합치려면 50번의 비교가 필요하다.
+
+매우 많은 숫자 카드 묶음이 책상 위에 놓여 있다. 이들을 두 묶음씩 골라 서로 합쳐나간다면, 고르는 순서에 따라서 비교 횟수가 매우 달라진다. 예를 들어 10장, 20장, 40장의 묶음이 있다면 10장과 20장을 합친 뒤, 합친 30장 묶음과 40장을 합친다면 (10 + 20) + (30 + 40) = 100번의 비교가 필요하다. 그러나 10장과 40장을 합친 뒤, 합친 50장 묶음과 20장을 합친다면 (10 + 40) + (50 + 20) = 120 번의 비교가 필요하므로 덜 효율적인 방법이다.
+
+N개의 숫자 카드 묶음의 각각의 크기가 주어질 때, 최소한 몇 번의 비교가 필요한지를 구하는 프로그램을 작성하시오.
+
+## 입력
+
+첫째 줄에 N이 주어진다. (1 ≤ N ≤ 100,000) 이어서 N개의 줄에 걸쳐 숫자 카드 묶음의 각각의 크기가 주어진다. 숫자 카드 묶음의 크기는 1,000보다 작거나 같은 양의 정수이다.
+
+## 출력
+
+첫째 줄에 최소 비교 횟수를 출력한다.
+
+## 풀이
+
+가장 작은 카드 뭉치를 시작으로 매번 가장 작은 카드 뭉치를 합치면 최소로 비교하면서 모든 카드를 합칠 수 있다. 왜냐하면 이렇게 해야만 합쳐진 카드 뭉치의 크기가 최소이고, 매번 합쳐진 카드 뭉치가 최소여야 비교하는 횟수도 최소이기 때문이다.
+
+매번 정렬된 수열이 필요하기 때문에 삽입 시에 정렬을 해치지 않는 우선순위 큐를 이용하여 풀었다.
+
+```python
+from queue import PriorityQueue
+
+n = int(input())
+pq = PriorityQueue()
+
+for _ in range(n):
+    num = int(input())
+    pq.put(num)
+
+result = 0
+
+while pq.qsize() > 1:
+    tmp = pq.get()
+    num = pq.get()
+    result += tmp + num
+    pq.put(tmp + num)
+
+print(result)
+```
+
+우선순위 큐에 입력으로 들어온 카드 뭉치의 크기를 삽입하고 반복문을 시작한다.
+
+우선순위 큐의 첫 번째, 두 번째 원소를 빼내서 더해준다 (카드 뭉치를 합침). 그리고 이를 결과가 저장될 result 함수에 저장해준다 (합칠 때 비교한 횟수를 반영). 마지막으로 첫 번째와 두 번째 원소의 합을 다시 우선순위 큐에 넣어준다. 다시 넣어주면 합쳐진 카드 뭉치를 자연스럽게 다시 합칠 수 있다.
+
+이를 우선순위 큐의 길이가 1보다 작아질 때까지 반복한다. 하나만 남았다는 것이 마지막 덧셈이 끝났다는 뜻이기 때문에 큐가 모두 빌 때까지 반복할 필요 없다.
\ No newline at end of file
diff --git a/_posts/2022-12-16-boj_2217.markdown b/_posts/2022-12-16-boj_2217.markdown
new file mode 100644
index 00000000000..4cd8b2b4357
--- /dev/null
+++ b/_posts/2022-12-16-boj_2217.markdown
@@ -0,0 +1,52 @@
+---
+title: "[BOJ] 로프 - 2217 (S4)"
+author: kwon
+date: 2022-12-16T23:00:00 +0900
+categories: [boj, silver]
+tags: [math, greedy algorithm, sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2초 | 192 MB |
+
+## 문제
+
+N(1 ≤ N ≤ 100,000)개의 로프가 있다. 이 로프를 이용하여 이런 저런 물체를 들어올릴 수 있다. 각각의 로프는 그 굵기나 길이가 다르기 때문에 들 수 있는 물체의 중량이 서로 다를 수도 있다.
+
+하지만 여러 개의 로프를 병렬로 연결하면 각각의 로프에 걸리는 중량을 나눌 수 있다. k개의 로프를 사용하여 중량이 w인 물체를 들어올릴 때, 각각의 로프에는 모두 고르게 w/k 만큼의 중량이 걸리게 된다.
+
+각 로프들에 대한 정보가 주어졌을 때, 이 로프들을 이용하여 들어올릴 수 있는 물체의 최대 중량을 구해내는 프로그램을 작성하시오. 모든 로프를 사용해야 할 필요는 없으며, 임의로 몇 개의 로프를 골라서 사용해도 된다.
+
+## 입력
+
+첫째 줄에 정수 N이 주어진다. 다음 N개의 줄에는 각 로프가 버틸 수 있는 최대 중량이 주어진다. 이 값은 10,000을 넘지 않는 자연수이다.
+
+## 출력
+
+첫째 줄에 답을 출력한다.
+
+## 풀이
+
+내림차순으로 정렬한 다음 순서대로 들 수 있는 무게를 비교한다.
+
+```python
+n = int(input())
+result = 0
+cnt = 0
+rope = []
+for i in range(0, n):
+    rope.append(int(input()))
+
+rope.sort(reverse=True)
+max_w = 0
+for cnt, r in enumerate(rope):
+    if max_w <= r * (cnt + 1):
+        max_w = r * (cnt + 1)
+
+print(max_w)
+```
+
+반복문을 돌면서 (로프의 개수) * (지금 확인한 로프의 무게)의 값이 저장해 놨던 무게 `max_w` 보다 크면 `max_w`를 바꿔준다.
\ No newline at end of file
diff --git a/_posts/2022-12-3-boj_1016.markdown b/_posts/2022-12-3-boj_1016.markdown
new file mode 100644
index 00000000000..7511ba79bc9
--- /dev/null
+++ b/_posts/2022-12-3-boj_1016.markdown
@@ -0,0 +1,79 @@
+---
+title: "[BOJ] 제곱 ㄴㄴ수 - 1016 (G1)"
+author: Kwon
+date: 2022-12-03T23:00:00 +0900
+categories: [boj, gold]
+tags: [prime number, sieve of Eratosthenes]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+|:-----------:|:-----------:|
+| 2초 | 512 MB |
+
+## 문제
+어떤 정수 X가 1보다 큰 제곱수로 나누어 떨어지지 않을 때, 그 수를 제곱ㄴㄴ수라고 한다. 제곱수는 정수의 제곱이다. min과 max가 주어지면, min보다 크거나 같고, max보다 작거나 같은 제곱ㄴㄴ수가 몇 개 있는지 출력한다.
+
+## 입력
+첫째 줄에 두 정수 min과 max가 주어진다.
+
+## 출력
+첫째 줄에 두 정수 min과 max가 주어진다.
+
+## 제한
+* 1 ≤ min ≤ 1,000,000,000,000
+* min ≤ max ≤ min + 1,000,000
+
+## 풀이
+2부터 증가하면서 제곱 수의 배수들을 빼주는 식으로 제곱 ㄴㄴ 수를 찾아가는 방식으로 문제를 해결하려 다음과 같이 시도하였다.
+
+### 첫 시도의 문제점
+```python
+n, m = map(int, input().split())
+sqr = [False] * (m - n + 1)
+cnt = 0
+for i in range(2, int(m ** 0.5) + 1):
+    j = 1
+    sqr_num = i ** 2
+    while sqr_num * j <= m:
+        if sqr_num * j < n: pass
+        elif not sqr[sqr_num * j - n]:
+            sqr[sqr_num * j - n] = True
+            cnt += 1
+        j += 1
+print((m - n + 1) - cnt)
+```
+
+소수의 배수를 빼며 소수를 찾아가는 에라토스테네스의 체(sieve of Eratosthenes) 알고리즘을 제곱 ㄴㄴ 수에 맞게 변형하여 사용하였다.
+
+하지만 위 코드는 체출시 시간 초과가 발생한다. 문제에서 주어진 수의 범위를 보면 최소가 1,000,001,000,000(= 1,000,000,000,000 + 1,000,000)까지 주어질 수 있기 때문에 `j`가 1부터 시작하면 엄청난 시간 낭비가 발생한다.
+
+n이라는 최소값이 존재하기 때문에  `sqr_num * j`가 `n`부터 바로 시작할 수 있도록 해주면 쓸모없는 연산의 낭비를 줄일 수 있다.
+
+```python
+# 실패
+j = 1
+
+# 성공
+j = n // sqr
+```
+
+그래서 위와 같이 `j`를 `n // sqr`부터 시작하도록 하여 코드를 수정하였다.
+
+### 수정한 코드
+```python
+n, m = map(int, input().split())
+cnt = 0
+prime = [1] * (m - n + 1)
+i = 2
+while i ** 2 <= m:
+    sqr = i ** 2
+    j = n // sqr
+    while sqr * j <= m:
+        if sqr * j >= n and prime[sqr * j - n] == 1:
+            prime[sqr * j - n] = 0
+        j += 1
+    i += 1
+print(sum(prime))
+```
\ No newline at end of file
diff --git a/_posts/2022-12-9-boj_13460.markdown b/_posts/2022-12-9-boj_13460.markdown
new file mode 100644
index 00000000000..08d1031a04a
--- /dev/null
+++ b/_posts/2022-12-9-boj_13460.markdown
@@ -0,0 +1,281 @@
+---
+title: "[BOJ] 구슬 탈출 2 - 13460 (G1)"
+author: kwon
+date: 2022-12-9T23:00:00 +0900
+categories: [boj, gold]
+tags: [implementation, graph, bfs, simulation]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+|:-----------:|:-----------:|
+| 2초 | 512 MB |
+
+## 문제
+스타트링크에서 판매하는 어린이용 장난감 중에서 가장 인기가 많은 제품은 구슬 탈출이다. 구슬 탈출은 직사각형 보드에 빨간 구슬과 파란 구슬을 하나씩 넣은 다음, 빨간 구슬을 구멍을 통해 빼내는 게임이다.
+
+보드의 세로 크기는 N, 가로 크기는 M이고, 편의상 1×1크기의 칸으로 나누어져 있다. 가장 바깥 행과 열은 모두 막혀져 있고, 보드에는 구멍이 하나 있다. 빨간 구슬과 파란 구슬의 크기는 보드에서 1×1크기의 칸을 가득 채우는 사이즈이고, 각각 하나씩 들어가 있다. 게임의 목표는 빨간 구슬을 구멍을 통해서 빼내는 것이다. 이때, **파란 구슬이 구멍에 들어가면 안 된다**.
+
+이때, 구슬을 손으로 건드릴 수는 없고, 중력을 이용해서 이리 저리 굴려야 한다. 왼쪽으로 기울이기, 오른쪽으로 기울이기, 위쪽으로 기울이기, 아래쪽으로 기울이기와 같은 네 가지 동작이 가능하다.
+
+각각의 동작에서 공은 동시에 움직인다. 빨간 구슬이 구멍에 빠지면 성공이지만, 파란 구슬이 구멍에 빠지면 실패이다. **빨간 구슬과 파란 구슬이 동시에 구멍에 빠져도 실패이다**. 빨간 구슬과 파란 구슬은 동시에 같은 칸에 있을 수 없다. 또, 빨간 구슬과 파란 구슬의 크기는 한 칸을 모두 차지한다. 기울이는 동작을 그만하는 것은 더 이상 구슬이 움직이지 않을 때 까지이다.
+
+보드의 상태가 주어졌을 때, 최소 몇 번 만에 빨간 구슬을 구멍을 통해 빼낼 수 있는지 구하는 프로그램을 작성하시오.
+
+## 입력
+첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B' 로 이루어져 있다. '.'은 빈 칸을 의미하고, '#'은 공이 이동할 수 없는 장애물 또는 벽을 의미하며, 'O'는 구멍의 위치를 의미한다. 'R'은 빨간 구슬의 위치, 'B'는 파란 구슬의 위치이다.
+
+입력되는 모든 보드의 가장자리에는 모두 '#'이 있다. 구멍의 개수는 한 개 이며, 빨간 구슬과 파란 구슬은 항상 1개가 주어진다.
+
+## 출력
+최소 몇 번 만에 빨간 구슬을 구멍을 통해 빼낼 수 있는지 출력한다. 만약, 10번 이하로 움직여서 빨간 구슬을 구멍을 통해 빼낼 수 없으면 -1을 출력한다.
+
+## 풀이
+
+맵을 BFS로 탐색하면서 시뮬레이션 하는 문제이다.
+
+처음 시도한 방식은 정말 단순하게 모두 다 구현하는 것으로 맵 리스트 자체에서 구슬들을 실제로 움직이는 것까지 구현하였다.
+
+```python
+# 테두리의 '#'은 필요없을 것이라 판단하고 빼고 입력 받음
+n, m  = map(int, input().split())
+o, r, b = (-1, ), (-1, ), (-1, )
+input()
+map_list = []
+for i in range(n - 2):
+    row = input()[1:-1]
+    if o[0] == -1:
+        o = (row.find('O'), i)
+    if r[0] == -1:
+        r = (row.find('R'), i)
+    if b[0] == -1:
+        b = (row.find('B'), i)
+   
+    map_list.append(list(row))
+input()
+
+# 기울였을 때 구슬을 움직이는 함수
+def tilt(map_list, dir, r, b):
+    rx, ry = r
+    bx, by = b
+    dir_x, dir_y = dir
+    
+    next_rx, next_ry = rx + dir_x, ry + dir_y   # 한 칸 이동
+    next_bx, next_by = bx + dir_x, by + dir_y
+    move_r = 0 <= next_ry < n - 2 and 0 <= next_rx < m - 2
+    move_b = 0 <= next_by < n - 2 and 0 <= next_bx < m - 2
+    
+    while move_r or move_b:
+        
+        if move_r:
+            next_r = map_list[next_ry][next_rx]
+            if next_r != '#' and not ((next_rx, next_ry) == (bx, by) and not move_b) and (rx, ry) != o:
+                rx = next_rx
+                ry = next_ry
+            elif (rx, ry) != o:
+                move_r = False
+        elif move_r:
+            move_r = False
+        
+        if move_r:
+            next_rx, next_ry = rx + dir_x, ry + dir_y   # 한 칸 이동
+            move_r = 0 <= next_ry < n - 2 and 0 <= next_rx < m - 2
+
+        if move_b:
+            next_b = map_list[next_by][next_bx]
+            if next_b != '#' and not((next_bx, next_by) == (rx, ry) and not move_r):
+                if next_b == 'O':
+                    return -1, -1, -1, -1
+                bx = next_bx
+                by = next_by
+            else:
+                move_b = False
+        elif move_b:
+            move_b = False
+        
+        if move_b:
+            next_bx, next_by = bx + dir_x, by + dir_y
+            move_b = 0 <= next_by < n - 2 and 0 <= next_bx < m - 2
+
+    return rx, ry, bx, by
+
+# 움직인 좌표를 바탕으로 실제 맵 리스트에 구슬을 표시하는 함수
+def move(dir, r, b):
+    m_rx, m_ry, m_bx, m_by = tilt(map_list, dir, r, b)
+    if m_rx == -1: return (-1, -1)  #
+    elif (m_rx, m_ry) == o: return (True, True)
+    else:
+        map_list[r[1]][r[0]], map_list[m_ry][m_rx] = map_list[m_ry][m_rx], map_list[r[1]][r[0]]
+        map_list[b[1]][b[0]], map_list[m_by][m_bx] = map_list[m_by][m_bx], map_list[b[1]][b[0]]
+        r, b = (m_rx, m_ry), (m_bx, m_by)
+        return r, b
+        
+visited = [[0] * (m - 2) for _ in range(n - 2)]
+
+# bfs를 통해 시뮬레이션 하는 함수
+def sim(r, b):
+    q = []
+    x, y = r
+    visited[y][x] = 1
+    q.append((r, None))
+    
+    while q:
+        cur = q.pop(0)
+        dirs = [(1, 0),(-1, 0),(0, 1),(0, -1)]
+        pre_d = cur[1]
+        cur = cur[0]
+        pre_cnt = visited[cur[1]][cur[0]]
+        if pre_d:
+            dirs.remove((-pre_d[0], -pre_d[1]))
+        for d in dirs:
+            if not(0 < r[1] + d[1] < n -2 or 0 < r[0] + d[0] < m - 2): continue
+            r_tmp, b_tmp = move(d, cur, b)
+            if (r_tmp, b_tmp) == (-1, -1): continue
+            if r_tmp == True:
+                return pre_cnt
+            elif pre_cnt >= 10:
+                return -1
+            elif visited[r_tmp[1]][r_tmp[0]] == 0:
+                r, b = r_tmp, b_tmp
+                q.append((r, d))
+                visited[r[1]][r[0]] = pre_cnt + 1
+    return -1
+
+print(sim(r, b))
+```
+
+### 첫 시도의 문제점
+
+1. **map_list에 실제로 구슬의 위치를 반영할 필요가 없다.**
+    1. 구슬 두 개의 좌표만 확실히 알고 있다면 모든 상호작용을 표현할 수 있다.
+    2. 하나의 리스트에 실제로 구슬의 위치를 반영하게 되면 bfs를 통해 시뮬레이션을 하는 데에 문제가 생긴다. 
+        * 이전까지 움직인 횟수가 같은 (= 탐색 진행 횟수가 같은) 다른 시도를 할 때 이전 시행이 이미 진행된 맵이기 때문에 정상적인 시행이 진행될 수 없다.
+    
+2. **visited 리스트의 차원이 빨간 구슬의 좌표만 체크한다.**
+    1. 빨간 구슬의 좌표가 같아도 파란 구슬의 위치가 달라 다른 상황일 수 있다.
+    
+3. **이외 다른 문제점**
+    1. 공이 다른 공에 닿아 멈추는 경우를 진행하는 도중에 공을 만나고 그 공이 이전에 움직이지 않았을 경우를 기준으로 판단하려 했지만 이것이 모든 경우를 다 커버할 수 있는지는 의문이다.
+    2. 입력을 받을 때 테두리를 제거해버리니 공들이 멈추는 조건이 추가되어야 했다.
+        * 테두리를 남겨둔다면 벽과 같은 방식으로 처리할 수 있어 코드 작성에 편리
+        * 테두리는 (m-2) * (n-2) 개의 원소만이 추가되며 n, m ≤ 10이므로 공간 복잡도에 큰 영향을 미치지 않을 것이라 판단하였음.
+
+위 코드는 결과적으로 시간 초과로 판단되었지만 채점이 계속 진행되었어도 문제가 발생할 가능성이 충분히 있어 보였다
+
+### 수정한 코드
+
+```python
+# 테두리 포함하여 입력 받음
+n, m  = map(int, input().split())
+o, r, b = (-1, ), (-1, ), (-1, )
+map_list = []
+for i in range(n):
+    row = input()
+    if o[0] == -1:
+        o = (row.find('O'), i)
+    if r[0] == -1:
+        r = (row.find('R'), i)
+    if b[0] == -1:
+        b = (row.find('B'), i)
+   
+    map_list.append(list(row))
+
+# 입력이 바뀜에 따라 공이 멈추는 조건이 더 간단해짐
+# 공이 공에 닿아 멈추는 경우도 다른 방식으로 처리
+def tilt(map_list, dir, r, b):
+    rx, ry = r
+    bx, by = b
+    dir_x, dir_y = dir
+    if dir_x != 0:
+        if dir_x * rx > dir_x * bx: late = 'b'
+        else: late = 'r'
+    else:
+        if dir_y * ry > dir_y * by: late = 'b'
+        else: late = 'r'
+    
+    cur_r = map_list[ry][rx]
+    cur_b = map_list[by][bx]
+    
+    next_r, next_b = '.', '.'
+    
+    while (next_r != '#' and cur_r != 'O') or (next_b != '#'):
+        next_r = map_list[ry + dir_y][rx + dir_x]
+        next_b = map_list[by + dir_y][bx + dir_x]
+        if next_r != '#' and cur_r != 'O':
+            cur_r = next_r
+            rx += dir_x
+            ry += dir_y
+        if next_b != '#':
+            cur_b = next_b
+            bx += dir_x
+            by += dir_y
+        if cur_b == 'O':
+            return -1, -1, -1, -1
+
+    if (rx, ry) == (bx, by):
+        if late == 'b':
+            bx -= dir_x
+            by -= dir_y
+        else:
+            rx -= dir_x
+            ry -= dir_y
+        
+    return rx, ry, bx, by
+        
+def move(dir, r, b):
+    m_rx, m_ry, m_bx, m_by = tilt(map_list, dir, r, b)
+    if m_rx == -1: return (-1, -1)
+    elif (m_rx, m_ry) == o: return (True, True)
+    else:
+        r, b = (m_rx, m_ry), (m_bx, m_by)
+        return r, b
+
+# visited가 빨간 공과 파란 공의 좌표를 모두 저장할 수 있게 수정 
+visited = [[[[0] * m for _ in range(n)] for _ in range(m)] for _ in range(n)]
+
+def sim(r, b):
+    q = []
+    q.append((r, b, None))
+    
+    while q:
+        cur_r, cur_b, pre_d = q.pop(0)
+        dirs = [(1, 0),(-1, 0),(0, 1),(0, -1)]
+        pre_cnt = visited[cur_r[1]][cur_r[0]][cur_b[1]][cur_b[0]]
+        
+        if pre_d:
+            dirs.remove(pre_d)
+            dirs.remove((-pre_d[0], -pre_d[1]))
+            
+        for d in dirs:
+            r_tmp, b_tmp = move(d, cur_r, cur_b)
+            if r_tmp == -1:
+                continue
+            elif r_tmp == True:
+                return pre_cnt + 1
+            elif pre_cnt >= 10:
+                return -1
+            elif not visited[r_tmp[1]][r_tmp[0]][b_tmp[1]][b_tmp[0]]:  # 방문 안함
+                q.append((r_tmp, b_tmp, d))
+                visited[r_tmp[1]][r_tmp[0]][b_tmp[1]][b_tmp[0]] = pre_cnt + 1
+        
+    return -1
+
+print(sim(r, b))
+```
+
+1. **map_list에 실제로 구슬의 위치를 반영할 필요가 없다.**
+    → 실제로 반영하는 코드를 삭제하고 좌표만 바꾸는 식으로 함수를 수정
+    
+2. **visited 리스트의 차원이 빨간 구슬의 좌표만 체크한다.**
+    → 2차원 리스트를 4차원 리스트로 바꿔서 둘 다 체크할 수 있도록 수정
+    
+3. **이외 다른 문제점**
+    1. 공이 다른 공에 닿아 멈추는 경우를 진행하는 도중에 공을 만나고 그 공이 이전에 움직이지 않았을 경우를 기준으로 판단하려 했다.
+        → 함수의 입력으로 받은 매개변수들을 기반으로 두 구슬의 최종 좌표가 겹칠 경우 나중에 도착한 구슬의 좌표를 한 칸 전으로 돌리는 방식으로 수정
+        
+    2. 입력을 받을 때 테두리를 제거해버리니 공들이 멈추는 조건이 추가되어야 했다.
+        → 그냥 테두리까지 다 받았다.
+        
+
+처음부터 너무 공간 복잡도를 줄이려고 해서 푸는데 더 오래 걸린 것 같다. 무작정 공간 복잡도를 줄이려고 하지 말고 입력의 크기와 주어진 문제의 메모리 제한을 잘 확인하고 적절한 선을 찾아서 하는 습관이 필요해 보인다.
\ No newline at end of file
diff --git a/_posts/2023-01-03-boj_25378.markdown b/_posts/2023-01-03-boj_25378.markdown
new file mode 100644
index 00000000000..b486bd118a8
--- /dev/null
+++ b/_posts/2023-01-03-boj_25378.markdown
@@ -0,0 +1,173 @@
+---
+title: "[BOJ][KOI] 조약돌 - 25378 (G1)"
+author: kwon
+date: 2022-12-16T23:00:00 +0900
+categories: [boj, gold]
+tags: [math, greedy algorithm, sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 0.5 초 | 1024 MB |
+
+# 문제
+
+좌우 한 줄로 있는 N개의 장소 각각에 조약돌이 몇 개씩 놓여 있다.
+
+철수가 할 수 있는 작업의 종류는 아래 두 가지이다.
+
+1. 인접한 두 장소에서 **임의의 동일한 개수**의 조약돌을 가져가기
+2. 한 장소에서 **임의의 개수**의 조약돌을 가져가기
+
+어떤 장소에 조약돌이 더 이상 없는 경우에도 그 장소는 그대로 남아 있어서, 초기에 인접하지 않았던 두 장소가 인접한 것으로 바뀌지 않는다.
+
+철수는 위의 두 작업 중 하나를 골라서 실행하는 것을 반복하여 모든 조약돌을 가져가려고 한다.
+
+초기에 각 장소에 있는 조약돌들의 개수를 입력받아, 철수가 할 수 있는 최소의 작업 횟수를 계산하는 프로그램을 작성하라.
+
+# 입력
+
+첫 번째 줄에 장소의 개수 N이 주어진다.
+
+두 번째 줄에 N개의 장소 각각에 있는 조약돌 개수가 왼쪽 장소에 해당하는 것부터 순서대로 공백 하나씩을 사이로 두고 주어진다.
+
+# 출력
+
+첫 번째 줄에 답을 출력한다.
+
+# 제한
+
+- 2 ≤ N ≤ 2 500
+- 각 장소의 초기 조약돌 개수는 $1$ 이상 $10^8$ 이하이다.
+    
+
+# 서브태스크
+
+| 번호 | 배점 | 제한 |
+| --- | --- | --- |
+| 1 | 6 | N = 3. |
+| 2 | 11 | N ≤ 15. |
+| 3 | 19 | N ≤ 300. |
+| 4 | 27 | 각 장소의 초기 조약돌 개수가 2 500 이하이다. |
+| 5 | 37 | 추가 제약 조건 없음. |
+
+# 풀이
+
+dynamic programing으로 접근해 보면 조약돌의 오른쪽에서 작업을 시작하여 각 자리마다 그 때의 최소 작업 횟수를 저장하여 memoization할 수 있다.
+
+하지만 단순히 이전까지의 최소 작업 횟수에 현재 자리의 최소 작업을 더한다고 최종적인 최소 작업 횟수가 될 수는 없다. 아래와 같은 예를 보자.
+
+> **1 3 2**
+
+조약돌의 개수가 위와 같이 주어졌을 경우 두 번째 자리까지 최소 횟수는 2이다. 이를 저장하고 다음으로 넘어가서 마지막 자리인 두 개의 조약돌을 빼내는 횟수 1을 단순히 더하면 총 횟수는 3회이다.
+
+하지만 처음부터 1번 작업으로 모두 진행하게 되면 두 번 만에 끝낼 수 있다.
+
+그러므로 단순히 이전까지 최소 횟수에 현재의 최소 횟수를 더하면 안된다.
+
+1번 작업과 2번 작업 간의 작업 횟수 차이를 조금 더 자세히 알아보자.
+
+**1번 작업**
+
+- r 번째에서 l 번째까지 1번 작업 만으로 모든 자리의 돌의 개수를 0으로 만들 수 있다고 했을 때 작업 횟수는 (l - r) 번이다. (r, r + 1), (r + 1, r + 2), … , (l - 2, l - 1), (l - 1, l) 이와 같은 쌍으로 작업이 진행되므로 (l -r)번 만에 작업을 끝낼 수 있다.
+
+**2번 작업**
+
+- 이 경우는 해당 범위의 모든 자리의 조약돌을 한 번씩 가져가는 것이므로 범위 내의 자리 개수인 (l - r + 1)과 같은 횟수만큼 작업을 해야 한다.
+
+자리의 범위에 따라 1번 작업으로만 조약돌을 모두 비울 수 있는지 여부가 완전히 달라지기 때문에 이 정보를 사용할 수 있도록 미리 모든 범위에 대해 1번 작업으로만 가능한지 체크해둔다.
+
+위에서 볼 수 있듯이 1번 작업을 최적으로 이용하는 방법을 찾는 것이 이 문제를 푸는데 중요하다는 것을 알 수 있다.
+
+체크하기 가장 쉬운 방법은 매번 인접한 두 조약돌에 대해 1번 작업을 하면서 매번 해당 범위의 조약돌 수의 합을 구해 합이 0이 되었는지 확인해보는 것이지만, 이 경우 $O(n^3)$의 시간복잡도를 가지기 때문에, 이 문제의 모든 서브태스크를 만족하기에 부적합하다.
+
+그래서 아래와 같은 방법을 사용한다.
+
+```python
+check = [[0] * n for _ in range(n)]
+
+for l in range(n - 1):
+    tmp = nums[l]
+
+    for r in range(l + 1, n):
+        if tmp == nums[r]:
+            check[l][r] = 1
+        elif tmp > nums[r]:
+            break
+        tmp = abs(tmp - nums[r])
+```
+
+임시 변수(`tmp`)에 1번 작업을 하고 남은 이전 조약돌의 개수를 저장한다. 임시 변수와 현재 확인하고 있는 자리의 조약돌 개수(`nums[r]`)가 같으면 1번 작업만으로 해당 범위의 자리를 모두 비울 수 있다는 것이므로 체크해준다.
+
+같지 않을 경우 그대로 놔두면 되지만 만약 임시 변수가 현재 조약돌 개수보다 크다면 어떻게 해도 1번 작업만 해서 모두 다 비울 수 없기 때문에 바로 반복문을 종료한다.
+
+위 경우에도 해당되지 않았으면 아직 1번 작업만으로 조약돌을 다 비울 수 있는 가능성이 남아있기 때문에 임시 변수에 임시 변수와 현재 조약돌 개수의 차이로 임시 변수의 값을 바꿔준다. 계속해서 두 값의 차로 값을 바꿔줘야 1번 작업을 하고 남은 이전 조약돌의 개수가 된다.
+
+이제 위에서 체크한 것을 이용하여 최소 시행을 찾아야 한다. 최소 횟수의 후보가 될 수 있는 값은 크게 두 가지가 있다.
+
+$memo[i]$는 $i$까지 작업을 수행했을 때의 최소 횟수, $2\leq i\leq N$ 범위에서 반복하며 확인할 것이므로 $memo[1]=1$로 초기화한다고 하자. 이때 최소 횟수의 후보는 다음과 같다.
+
+1. $memo[i-1] + 1$
+    
+    : 이전까지 최소 횟수에 이번 자리의 조약돌을 2번 작업으로 빼내는 횟수(1)를 더한 것
+    
+2. $\min_{1\leq j < i, check[j][i]=1}(memo[j - 1]+i-j)$ $(2\leq i\leq N)$
+    
+    : 범위가 바뀌었으니 새롭게 1번 작업만으로 비우기가 가능한 범위(체크된 범위)가 있는지 찾아보는 과정이다. $1\leq j < i$를 만족하는 $j$부터 시작해서 새로운 범위의 끝($i$)까지 확인하면서 체크한 범위가 있는지 확인하고 체크된 것이 확인되면 ($check[j][i]=1$) 횟수를 계산한다.
+    
+    새롭게 찾은 범위가 시작하기 전까지의 최소 횟수($memo[j - 1]$)와 새로운 범위에서 1번 작업을 한 횟수($i-j$)를 더해주면 전체 횟수를 계산할 수 있다.
+    
+
+위 과정으로 구한 두 값 중 작은 것을 해당 위치에서의 최소 횟수로 취하면 된다. 전체 점화식은 다음과 같이 표현할 수 있다.
+
+$$memo[i]=\min\{memo[i-1]+1, \min_{1\leq j < i, check[j][i]=1}(memo[j - 1]+i-j)\}$$
+
+```python
+memo = [0] * (n + 1)
+memo[1] = 1
+
+for i in range(2, n + 1):
+    new_min = float('inf')
+    for j in range(1, i):
+        if check[j - 1][i - 1] == 1:
+            new = memo[j - 1] + i - j
+            if new_min > new:
+                new_min = new
+            
+    memo[i] = min(memo[i - 1] + 1, new_min)
+print(memo[-1])
+```
+
+## 전체 코드
+
+```python
+n = int(input())
+nums = list(map(int, input().split()))
+
+check = [[0] * n for _ in range(n)]
+memo = [0] * (n + 1)
+memo[1] = 1
+
+for l in range(n - 1):
+    tmp = nums[l]
+
+    for r in range(l + 1, n):
+        if tmp == nums[r]:
+            check[l][r] = 1
+        elif tmp > nums[r]:
+            break
+        tmp = abs(tmp - nums[r])
+
+for i in range(2, n + 1):
+    new_min = float('inf')
+    for j in range(1, i):
+        if check[j - 1][i - 1] == 1:
+            new = memo[j - 1] + i - j
+            if new_min > new:
+                new_min = new
+            
+    memo[i] = min(memo[i - 1] + 1, new_min)
+print(memo[-1])
+```
\ No newline at end of file
diff --git a/_posts/2023-02-02-boj_1003.markdown b/_posts/2023-02-02-boj_1003.markdown
new file mode 100644
index 00000000000..1c5648002c9
--- /dev/null
+++ b/_posts/2023-02-02-boj_1003.markdown
@@ -0,0 +1,90 @@
+---
+title: "[BOJ]피보나치 함수- 1003 (S3)"
+author: kwon
+date: 2023-02-02T23:00:00 +0900
+categories: [boj, silver]
+tags: [dynamic programing]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 0.25 초 (추가 시간 없음) | 128 MB |
+
+# 문제
+
+다음 소스는 N번째 피보나치 수를 구하는 C++ 함수이다.
+
+```
+int fibonacci(int n) {
+    if (n == 0) {
+        printf("0");
+        return 0;
+    } else if (n == 1) {
+        printf("1");
+        return 1;
+    } else {
+        return fibonacci(n‐1) + fibonacci(n‐2);
+    }
+}
+
+```
+
+`fibonacci(3)`을 호출하면 다음과 같은 일이 일어난다.
+
+- `fibonacci(3)`은 `fibonacci(2)`와 `fibonacci(1)` (첫 번째 호출)을 호출한다.
+- `fibonacci(2)`는 `fibonacci(1)` (두 번째 호출)과 `fibonacci(0)`을 호출한다.
+- 두 번째 호출한 `fibonacci(1)`은 1을 출력하고 1을 리턴한다.
+- `fibonacci(0)`은 0을 출력하고, 0을 리턴한다.
+- `fibonacci(2)`는 `fibonacci(1)`과 `fibonacci(0)`의 결과를 얻고, 1을 리턴한다.
+- 첫 번째 호출한 `fibonacci(1)`은 1을 출력하고, 1을 리턴한다.
+- `fibonacci(3)`은 `fibonacci(2)`와 `fibonacci(1)`의 결과를 얻고, 2를 리턴한다.
+
+1은 2번 출력되고, 0은 1번 출력된다. N이 주어졌을 때, `fibonacci(N)`을 호출했을 때, 0과 1이 각각 몇 번 출력되는지 구하는 프로그램을 작성하시오.
+
+# 입력
+
+첫째 줄에 테스트 케이스의 개수 T가 주어진다.
+
+각 테스트 케이스는 한 줄로 이루어져 있고, N이 주어진다. N은 40보다 작거나 같은 자연수 또는 0이다.
+
+# 출력
+
+각 테스트 케이스마다 0이 출력되는 횟수와 1이 출력되는 횟수를 공백으로 구분해서 출력한다.
+
+# 풀이
+
+각 수를 통해 피보나치 함수를 호출했을 때 0과 1이 출력 되는 횟수를 각 딕셔너리에 memoization하여 0과 1의 출력 횟수를 구한다. 단순히 피보나치 수를 구하는 것이 아니라 개수를 구하는 것이기 때문에 (0의 횟수, 1의 횟수)를 return하도록 함수를 작성한다.
+
+## 코드
+
+```python
+n = int(input())
+
+memo1 = {}
+memo2 = {}
+
+def fib(n):
+    if n == 0:
+        return 1, 0
+    elif n == 1:
+        return 0, 1
+    
+    if n in memo1:
+        zero = memo1[n]
+    if n in memo2:
+        one = memo2[n]
+    else:
+        zero1, one1 = fib(n - 1)
+        zero2, one2 = fib(n - 2)
+        zero = zero1 + zero2
+        one = one1 + one2
+        memo1[n] = zero
+        memo2[n] = one
+    return zero, one
+
+for _ in range(n):
+    num = int(input())
+    print(*fib(num), sep=' ')
+```
\ No newline at end of file
diff --git a/_posts/2023-02-04-boj_1005.markdown b/_posts/2023-02-04-boj_1005.markdown
new file mode 100644
index 00000000000..451a73416b8
--- /dev/null
+++ b/_posts/2023-02-04-boj_1005.markdown
@@ -0,0 +1,293 @@
+---
+title: "[BOJ]ACM Craft - 1005 (G3)"
+author: kwon
+date: 2023-02-04T14:00:00 +0900
+categories: [boj, gold]
+tags: [dynamic programing, graph theory, topological sort]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1 초 | 512 MB |
+
+# 문제
+
+서기 2012년! 드디어 2년간 수많은 국민들을 기다리게 한 게임 ACM Craft (Association of Construction Manager Craft)가 발매되었다.
+
+이 게임은 지금까지 나온 게임들과는 다르게 ACM크래프트는 다이나믹한 게임 진행을 위해 건물을 짓는 순서가 정해져 있지 않다. 즉, 첫 번째 게임과 두 번째 게임이 건물을 짓는 순서가 다를 수도 있다. 매 게임시작 시 건물을 짓는 순서가 주어진다. 또한 모든 건물은 각각 건설을 시작하여 완성이 될 때까지 Delay가 존재한다.
+
+![](https://www.acmicpc.net/upload/201003/star.JPG)
+
+위의 예시를 보자.
+
+이번 게임에서는 다음과 같이 건설 순서 규칙이 주어졌다. 1번 건물의 건설이 완료된다면 2번과 3번의 건설을 시작할수 있다. (동시에 진행이 가능하다) 그리고 4번 건물을 짓기 위해서는 2번과 3번 건물이 모두 건설 완료되어야지만 4번건물의 건설을 시작할수 있다.
+
+따라서 4번건물의 건설을 완료하기 위해서는 우선 처음 1번 건물을 건설하는데 10초가 소요된다. 그리고 2번 건물과 3번 건물을 동시에 건설하기 시작하면 2번은 1초뒤에 건설이 완료되지만 아직 3번 건물이 완료되지 않았으므로 4번 건물을 건설할 수 없다. 3번 건물이 완성되고 나면 그때 4번 건물을 지을수 있으므로 4번 건물이 완성되기까지는 총 120초가 소요된다.
+
+프로게이머 최백준은 애인과의 데이트 비용을 마련하기 위해 서강대학교배 ACM크래프트 대회에 참가했다! 최백준은 화려한 컨트롤 실력을 가지고 있기 때문에 모든 경기에서 특정 건물만 짓는다면 무조건 게임에서 이길 수 있다. 그러나 매 게임마다 특정건물을 짓기 위한 순서가 달라지므로 최백준은 좌절하고 있었다. 백준이를 위해 특정건물을 가장 빨리 지을 때까지 걸리는 최소시간을 알아내는 프로그램을 작성해주자.
+
+# 입력
+
+첫째 줄에는 테스트케이스의 개수 T가 주어진다. 각 테스트 케이스는 다음과 같이 주어진다. 첫째 줄에 건물의 개수 N과 건물간의 건설순서 규칙의 총 개수 K이 주어진다. (건물의 번호는 1번부터 N번까지 존재한다)
+
+둘째 줄에는 각 건물당 건설에 걸리는 시간 D1, D2, ..., DN이 공백을 사이로 주어진다. 셋째 줄부터 K+2줄까지 건설순서 X Y가 주어진다. (이는 건물 X를 지은 다음에 건물 Y를 짓는 것이 가능하다는 의미이다)
+
+마지막 줄에는 백준이가 승리하기 위해 건설해야 할 건물의 번호 W가 주어진다.
+
+# 출력
+
+건물 W를 건설완료 하는데 드는 최소 시간을 출력한다. 편의상 건물을 짓는 명령을 내리는 데는 시간이 소요되지 않는다고 가정한다.
+
+건설순서는 모든 건물이 건설 가능하도록 주어진다.
+
+# 풀이
+
+## 첫 접근
+
+처음 문제를 봤을 때는 그래프 구조 문제이고,  BFS를 기반으로 접근해야겠다고 생각했다. DFS로 접근하면 목표한 건물이 없는 길이 너무 깊다면 시간 복잡도가 너무 증가할 것이라고 생각했다. 또한  한 건물로 가는 길이 여러 개이며, 목표 건물에 도달하는 길을 모두 탐색했으면 더 깊게 탐색할 필요가 없기 때문에 DFS는 매우 불리할 것이라 생각했다.
+
+문제에서는 어떤 건물로 건축을 시작해야 하는지 정확히 명시하지 않고 있다. 그래서 코드 내에서 이를 해결해 주어야 한다. 어떤 건물이 처음으로 지어질 수 있다는 것은 그 건물을 짓기 전에 다른 건물들을 지을 필요가 없다는 뜻이며 이는 건설 순서를 입력 받을 때 Y로 입력되지 않았던 값이다. Y로 한 번이라도 입력된 값은 적어도 하나 이상의 건물을 지어야 그 건물을 지을 수 있다는 것이기 때문이다. 처음 시작하는 건물들은 다음과 같이 찾아낼 수 있다.
+
+```python
+		...
+    first_val = list(range(1, n + 1))
+    for i in range(k):
+        x, y = map(int, input().split())
+        xy_dict[x].append(y)
+        ...
+        try: first_val.remove(y)
+        except: pass
+		...
+```
+
+모든 건물 번호가 들어가 있는 배열에서 Y로 입력된 값들만 삭제한다. 이후 탐색하면서 `time`딕셔너리에 건물 번호 : 짓는데 걸리는 시간을 key : vlaue로 저장해준다. 시간을 저장할 때는 여러 건물을 동시에 지을 수 있기 때문에 탐색하면서 계산한 시간들 중에 가장 큰 것만 저장하면 된다. 코드는 다음과 같다.
+
+```python
+				...
+        for k in keys:
+            tmp = []
+            for v in xy_dict[k]:
+                ...
+                if v not in times:
+                    times[v] = times[k] + d_list[v - 1]
+                else:
+                    times[v] = max(times[k] + d_list[v - 1], times[v])
+				...
+```
+
+탐색하면서 나온 건물들(`v`)을 다시 queue에 넣어주면서 BFS를 진행한다.
+
+다만, 목표 건물이 Y로 한 번도 등장하지 않았다면 필요 건물이 없다는 것이므로 바로 목표 건물의 건축 시간을 출력한다.
+
+```python
+		...
+    if counts[target] != 0:
+        print(bfs(xy_dict, d_list, first_val, target, counts[target]))
+    else:
+        print(d_list[target - 1])
+```
+
+하지만 이렇게 처리를 하고 BFS 기반으로만 풀어나가면 모든 경우들을 처리하기 쉽지 않다. 다음 예제를 보자.
+
+```
+1
+5 10
+100000 99999 99997 99994 99990
+4 5
+3 5
+3 4
+2 5
+2 4
+2 3
+1 5
+1 4
+1 3
+1 2
+4
+```
+
+입력되는 순서를 변경하지 않고 단순하게 탐색을 진행하면 2, 3 번 건물의 탐색이 끝나기 전에 4번의 탐색이 완료되어 버려 오답이 출력 된다.
+
+### 첫 접근 전체 코드
+
+```python
+import sys
+from collections import defaultdict
+input = sys.stdin.readline
+
+def bfs(xy_dict, d_list, first_val, target, target_num):
+    first_idx = 0
+    q = []
+    times = {}
+    times[first_val[0]] = d_list[first_val[0] - 1]
+    keys = [first_val[0]]
+    while True:
+        if q:
+            keys = q.pop(0)
+        for k in keys:
+            tmp = []
+            for v in xy_dict[k]:
+                if target == v: target_num -= 1
+                tmp.append(v)
+                if v not in times:
+                    times[v] = times[k] + d_list[v - 1]
+                else:
+                    times[v] = max(times[k] + d_list[v - 1], times[v])
+            q.append(tmp)
+            if target_num == 0:
+                return times[target]
+        if not q:
+            first_idx += 1
+            next = first_val[first_idx]
+            times[next] = d_list[next - 1]
+            keys = [next]
+
+t = int(input())
+for _ in range(t):
+    n, k = map(int, input().split())
+    xy_dict = defaultdict(list)
+    d_list = list(map(int, input().split()))
+    
+    counts = {i:0 for i in range(1, n + 1)}
+    first_val = list(range(1, n + 1))
+    for i in range(k):
+        x, y = map(int, input().split())
+        xy_dict[x].append(y)
+        counts[y] += 1
+        try: first_val.remove(y)
+        except: pass
+    target = int(input())
+    for x in xy_dict:
+        xy_dict[x].sort(key=lambda x: counts[x])
+    if counts[target] != 0:
+        print(bfs(xy_dict, d_list, first_val, target, counts[target]))
+    else:
+        print(d_list[target - 1])
+```
+
+## 다른 접근
+
+다른 방식의 접근이 필요하다 생각하여 순서를 정하는 주요한 요인이 무엇일까 생각해 봤다. 위 방식에서 문제가 됐던 것은 먼저 지어져야 할 건물의 탐색이 끝나기 전에 다음 단계의 건물을 탐색하기 시작한다는 것이다. 이때 건물들의 순서는 해당 건물의 짓기 위해 먼저 지어야 하는 건물들의 개수로 정의할 수 있다.
+
+```
+1
+5 10
+100000 99999 99997 99994 99990
+4 5
+3 5
+3 4
+2 5
+2 4
+2 3
+1 5
+1 4
+1 3
+1 2
+4
+```
+
+위에서 봤던 예제를 다시 보면서 생각해보자.
+
+각 건물들의 짓기 위해 필요한 건물들의 개수를 나타내보면 다음과 같다.
+
+| 건물 번호 | 1 | 2 | 3 | 4 | 5 |
+| --- | --- | --- | --- | --- | --- |
+| 필요 건물 | 0 | 1 | 2 | 3 | 4 |
+
+필요 건물이 많을수록 뒤에 탐색하면 위에서 말했던 문제를 해결할 수 있다.
+
+탐색을 할 건물은 항상 필요 건물이 0인 것들로만 구성할 것이다. 이를 어떻게 하는지 탐색 과정을 세세하게 확인해 보자. 현재 건물들의 관계를 그래프로 나타내면 다음과 같다.
+
+![](/posting_imgs/boj-1005.png)
+
+| 건물 번호 | 1 | 2 | 3 | 4 | 5 |
+| --- | --- | --- | --- | --- | --- |
+| 필요 건물 | 0 | 1 | 2 | 3 | 4 |
+
+queue: 1
+
+탐색 완료:
+
+처음에는 필요 건물이 0인 경우가 1 밖에 없으므로 queue에 1을 넣어준다.
+
+| 건물 번호 | 1 | 2 | 3 | 4 | 5 |
+| --- | --- | --- | --- | --- | --- |
+| 필요 건물 | 0 | 0 | 1 | 2 | 3 |
+
+queue: 2
+
+탐색 완료: 1
+
+1은 2, 3, 4, 5와 연결되어 있으므로 1의 탐색이 끝나면(다 지어지면) 2, 3, 4, 5의 필요 건물을 하나씩 줄일 수 있다. 필요 건물을 줄인 후에 탐색이 가능한 건물은 2번이다(필요 건물이 0이 되었기 때문). 이런 방식으로 계속 탐색한다.
+
+| 건물 번호 | 1 | 2 | 3 | 4 | 5 |
+| --- | --- | --- | --- | --- | --- |
+| 필요 건물 | 0 | 0 | 0 | 1 | 2 |
+
+queue: 3
+
+탐색 완료: 1, 2
+
+| 건물 번호 | 1 | 2 | 3 | 4 | 5 |
+| --- | --- | --- | --- | --- | --- |
+| 필요 건물 | 0 | 0 | 0 | 0 | 1 |
+
+queue: 4
+
+탐색 완료: 1, 2, 3
+
+이렇게 목표 건물이 4번이 queue에 들어와 탐색을 마치면 4번 건물을 지었다는 것이므로 탐색을 멈추고 저장해두었던 시간을 출력하면 된다.
+
+이 문제의 입력으로 주어지는 건물들로 만들어진 그래프는 항상 방향성을 가지며, 항상 모든 건물이 건축 가능하도록 주어진다고 했기 때문에 acyclic이다. 즉 이 문제의 그래프는 DAG(Directed Acyclic Graph)이다. DAG에서 어떤 노드로 들어오는 간선의 개수를 indegree라고 하는데 이 indegree의 개수에 따라 정렬하는 것을 위상 정렬(topologicla sort)이라고 한다.
+
+따라서 우리가 위에서 필요 건물(indegree)에 따라 정렬하여 시간을 계산한 것은 위상 정렬을 이용한 알고리즘인 것이다.
+
+### 최종 전체 코드
+
+```python
+import sys
+from collections import defaultdict
+input = sys.stdin.readline
+
+def topological_sort(xy_dict, d_list, first_val, counts, target):
+    times = {val:d_list[val - 1] for val in first_val}
+    q = first_val
+    
+    while q:
+        cur = q.pop(0)
+        if cur == target: return times[target]
+        for next in xy_dict[cur]:
+            if next not in times:
+                times[next] = times[cur] + d_list[next - 1]
+            else:
+                times[next] = max(times[cur] + d_list[next - 1], times[next])
+            counts[next] -= 1
+        tmp = list(counts.keys())[:]
+        for i in tmp:
+            if counts[i] == 0:
+                q.append(i)
+                del counts[i]
+
+t = int(input())
+for _ in range(t):
+    n, k = map(int, input().split())
+    xy_dict = defaultdict(list)
+    d_list = list(map(int, input().split()))
+    
+    counts = defaultdict(int)
+    first_val = list(range(1, n + 1))
+    for i in range(k):
+        x, y = map(int, input().split())
+        xy_dict[x].append(y)
+        counts[y] += 1
+        try: first_val.remove(y)
+        except: pass
+    target = int(input())
+        
+    if target in counts:
+        print(topological_sort(xy_dict, d_list, first_val, counts, target))
+    else:
+        print(d_list[target - 1])
+```
\ No newline at end of file
diff --git a/_posts/2023-02-04-boj_1074.markdown b/_posts/2023-02-04-boj_1074.markdown
new file mode 100644
index 00000000000..fe99691b7e3
--- /dev/null
+++ b/_posts/2023-02-04-boj_1074.markdown
@@ -0,0 +1,111 @@
+---
+title: "[BOJ]Z - 1074 (S1)"
+author: kwon
+date: 2022-03-10T14:00:00 +0900
+categories: [boj, silver]
+tags: [divide and conquer, recursion]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 0.5 초 | 512 MB |
+
+tag: divide and conquer, recursion
+
+# 문제
+
+한수는 크기가 $2^N×2^N$인 2차원 배열을 Z모양으로 탐색하려고 한다. 예를 들어, 2×2배열을 왼쪽 위칸, 오른쪽 위칸, 왼쪽 아래칸, 오른쪽 아래칸 순서대로 방문하면 Z모양이다.
+
+![](https://u.acmicpc.net/21c73b56-5a91-43aa-b71f-9b74925c0adc/Screen%20Shot%202020-12-02%20at%208.09.46%20AM.png)
+
+N > 1인 경우, 배열을 크기가 $2^{N-1}×2^{N-1}$로 4등분 한 후에 재귀적으로 순서대로 방문한다.
+
+다음 예는 22 × 2 크기의 배열을 방문한 순서이다.
+
+![](https://u.acmicpc.net/adc7cfae-e84d-4d5c-af8e-ee011f8fff8f/Screen%20Shot%202020-12-02%20at%208.11.17%20AM.png)
+
+N이 주어졌을 때, r행 c열을 몇 번째로 방문하는지 출력하는 프로그램을 작성하시오.
+
+다음은 N=3일 때의 예이다.
+
+![](https://u.acmicpc.net/d3e84bb7-9424-4764-ad3a-811e7fcbd53f/Screen%20Shot%202020-12-30%20at%2010.50.47%20PM.png)
+
+# 입력
+
+첫째 줄에 정수 N, r, c가 주어진다.
+
+# 출력
+
+r행 c열을 몇 번째로 방문했는지 출력한다.
+
+# 제한
+
+- $1≤N≤15$
+- $0≤r,c<2^N$
+
+# 풀이
+
+수의 크기 제한이 $2^{15}$인 만큼 모두 재귀로 탐색하는 것은 제한 시간을 맞추지 못한다. 보통 1초에 약 $10^8$번의 연산을 한다고 생각하므로 O(N)으로도 해결할 수 없어진다.
+
+그러므로 주어진 x, y가 있는 영역으로 빠르게 다가갈 수 있는 다른 방법을 찾아야 한다. 하나의 큰 Z는 이를 사등분하여 작은 Z를 만들 수 있다. 이를 활용하여 주어진 x, y가 해당 영역의 각 변을 직각 이등분 하는 직선을 기준으로 큰지 작은지 확인하면 4개의 작은 영역 중에 어디 속해있는지 알 수 있다. 2차원에서 진행하는 일종의 이분 탐색이라고 할 수도 있겠다.
+
+x, y가 어느 영역에 속하는지 확인하는 코드는 다음과 같이 작성하였다. 뒤에 따라오는 그림과 함께 보자.
+
+```python
+...
+		num = 2 ** (N - 1)
+		# 좌상단
+    if x <= num and y <= num:
+        position(N-1, x, y, base)
+        
+		# 우상단
+    elif x > num and y <= num:
+        position(N-1, x - num, y, 4 ** (N - 1) + base)
+    
+		# 좌하단
+    elif x <= num and y > num:
+        position(N-1, x, y - num, 2 * 4 ** (N - 1) + base)
+        
+		# 우하단
+    elif x > num and y > num:
+        position(N-1, x - num, y - num, 3 * 4 ** (N - 1) + base)
+```
+
+![](/posting_imgs/boj_1074.jpg)
+
+위와 같이 한 변이 $2^n$인 영역이 주어졌을 때 각 변을 직각 이등분 하는 선은 가장 좌상단의 꼭짓점에서 $2^n/2(=2^{n-1})$ 만큼 떨어져 있는 것을 확인할 수 있다. 그러므로 x, y가 $2^{n-1}$보다 큰지 작은지 확인하면 네 개의 영역 중 어디에 속해있는지 알 수 있다. 단 여기서 x는 커질수록 오른쪽, y는 커질수록 아래로 진행한다고 생각해야 한다.
+
+base는 말 그대로 지금 확인하려 하는 영역의 기준 칸을 뜻하는 것으로 가장 좌상단에  위치하는 칸을 뜻한다. 그리고 이 base는 원하는 점이 어느 영역에 속하는 지에 따라 계속 바뀌어야 한다. 즉, 각 영역에 따라 노란색으로 칠한 칸이 다음 영역의 base가 된다. 그리고 이 base는 Z 순서에 따라 $base+0,base+(4^{n-1}),base+(2\times4^{n-1}),base+(3\times4^{n-1})$로 계산할 수 있다. 이는 작은 영역에 속한 칸의 개수가 $2^{n-1}\times2^{n-1}(=4^{n-1})$이기 때문이다.
+
+## 코드
+
+```python
+import sys
+N, y, x = map(int, sys.stdin.readline().split())
+
+def position(N, x, y, base=0):
+    if N == 0 or (x <= 1 and y <= 1):
+        print(base)
+        return base
+    
+    num = 2 ** (N - 1)
+    if x <= num and y <= num:
+        position(N-1, x, y, base)
+        
+    elif x > num and y <= num:
+        position(N-1, x - num, y, 4 ** (N - 1) + base)
+    
+    elif x <= num and y > num:
+        position(N-1, x, y - num, 2 * 4 ** (N - 1) + base)
+        
+    elif x > num and y > num:
+        position(N-1, x - num, y - num, 3 * 4 ** (N - 1) + base)
+        
+position(N, x + 1, y + 1)
+```
+
+위에서 설명한 알고리즘을 따라 계속 진행한다. 다만, 설명할 때는 x, y값이 변하지 않는 것으로 생각하고 진행했지만 편의를 위해 x, y 중 변하는 좌표에 $2^{n-1}$를 빼며 진행하였다. 필요 없는 영역을 잘라내면서 진행한다고 생각하면 된다. x, y의 값이 실제와 달라져도 base의 값만 알맞게 계산하면 정답을 찾아낼 수 있다.
+
+N이 0이 되거나 x, y가 모두 1 이하이면 찾으려는 칸에 도달했다는 뜻이므로 답을 출력하고 중지한다.
\ No newline at end of file
diff --git a/_posts/2023-12-05-boj_1157.markdown b/_posts/2023-12-05-boj_1157.markdown
new file mode 100644
index 00000000000..e016d05641c
--- /dev/null
+++ b/_posts/2023-12-05-boj_1157.markdown
@@ -0,0 +1,58 @@
+---
+title: "[BOJ]단어 공부 - 1157 (B1)"
+author: kwon
+date: 2023-12-05T14:00:00 +0900
+categories: [boj, bronze]
+tags: [implementation, string]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 128 MB |
+
+# 문제
+
+알파벳 대소문자로 된 단어가 주어지면, 이 단어에서 가장 많이 사용된 알파벳이 무엇인지 알아내는 프로그램을 작성하시오. 단, 대문자와 소문자를 구분하지 않는다.
+
+# 입력
+
+첫째 줄에 알파벳 대소문자로 이루어진 단어가 주어진다. 주어지는 단어의 길이는 1,000,000을 넘지 않는다.
+
+# 출력
+
+첫째 줄에 이 단어에서 가장 많이 사용된 알파벳을 대문자로 출력한다. 단, 가장 많이 사용된 알파벳이 여러 개 존재하는 경우에는 ?를 출력한다.
+
+# 풀이
+
+dictionary를 사용하여 등장하는 알파벳의 개수를 세어준다. 그리고 해당 알파벳의 개수가 저장된 최대 개수보다 많으면 그 알파벳과 그 개수를 저장한다. 만약 알파벳의 개수가 저장된 최대 개수와 정확히 같다면 가장 많이 사용된 알파벳이 그 순간에 여러 개 존재한다는 것이므로 변수(`same_chk`)를 통해 체크해준다.
+
+만약 체크 되어 있다면 ‘?’를, 아니면 저장되어 있는 최대 개수의 알파벳을 출력한다.
+
+## 코드
+
+```python
+from collections import defaultdict
+word = input().upper()
+
+counter = defaultdict(int)
+
+max_cnt = 0
+max_alpha = ''
+same_chk = False
+
+for a in word:
+    counter[a] += 1
+    if counter[a] > max_cnt:
+        max_cnt = counter[a]
+        max_alpha = a
+        same_chk = False
+    elif counter[a] == max_cnt:
+        same_chk = True
+
+if same_chk:
+    print('?')
+else:
+    print(max_alpha)
+```
\ No newline at end of file
diff --git a/_posts/2024-07-31-swea_5215.markdown b/_posts/2024-07-31-swea_5215.markdown
new file mode 100644
index 00000000000..2eaf5f91124
--- /dev/null
+++ b/_posts/2024-07-31-swea_5215.markdown
@@ -0,0 +1,198 @@
+---
+title: "[SWEA]햄버거 다이어트 - 5215 (D3)"
+author: kwon
+date: 2024-07-31T14:00:00 +0900
+categories: [swea, d3]
+tags: [dfs, greedy algorithm]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 16 초 | 힙 정적 메모리: 256 MB / 스택 메모리 1MB |
+
+# 문제
+
+
+평소 햄버거를 좋아하던 민기는 최근 부쩍 늘어난 살 때문에 걱정이 많다.
+
+그렇다고 햄버거를 포기할 수 없었던 민기는 햄버거의 맛은 최대한 유지하면서 정해진 칼로리를 넘지 않는 햄버거를 주문하여 먹으려고 한다.
+ 
+
+민기가 주로 이용하는 햄버거 가게에서는 고객이 원하는 조합으로 햄버거를 만들어서 준다.
+
+하지만 재료는 미리 만들어서 준비해놓기 때문에 조합에 들어가는 재료를 잘라서 조합해주지는 않고, 재료를 선택하면 준비해놓은 재료를 그대로 사용하여 조합해준다. 
+
+민기는 이 가게에서 자신이 먹었던 햄버거의 재료에 대한 맛을 자신의 오랜 경험을 통해 점수를 매겨놓았다.
+
+민기의 햄버거 재료에 대한 점수와 가게에서 제공하는 재료에 대한 칼로리가 주어졌을 때,
+
+민기가 좋아하는 햄버거를 먹으면서도 다이어트에 성공할 수 있도록 정해진 칼로리 이하의 조합 중에서 민기가 가장 선호하는 햄버거를 조합해주는 프로그램을 만들어보자.
+
+(단 여러 재료를 조합하였을 햄버거의 선호도는 조합된 재료들의 맛에 대한 점수의 합으로 결정되고, 같은 재료를 여러 번 사용할 수 없으며, 햄버거의 조합의 제한은 칼로리를 제외하고는 없다.)
+
+# 입력
+
+첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
+ 
+
+각 테스트 케이스의 첫 번째 줄에는 재료의 수, 제한 칼로리를 나타내는 N, L(1 ≤ N ≤ 20, 1 ≤ L ≤ 104)가 공백으로 구분되어 주어진다.
+ 
+
+다음 N개의 줄에는 재료에 대한 민기의 맛에 대한 점수와 칼로리를 나타내는 Ti, Ki(1 ≤ $T_i$ ≤ 103, 1 ≤ Ki ≤ 103)가 공백으로 구분되어 주어진다.
+
+# 출력
+
+각 줄마다 "#T" (T는 테스트 케이스 번호)를 출력한 뒤, 주어진 제한 칼로리 이하의 조합중에서 가장 맛에 대한 점수가 높은 햄버거의 점수를 출력한다.
+
+# 풀이
+
+## DFS를 활용한 풀이
+
+가장 먼저 떠오른 방식은 DFS를 활용한 방식이다.
+햄버거 재료를 하나씩 사용하며(재료 수를 하나씩 줄여가며) 재귀를 반복한다.
+사용한 재료에 맞게 칼로리와 점수를 더해서 다음 재귀의 매개변수로 넘겨준다.
+그리고 매 시행마다 점수가 최대인지 확인하고 기록해준다.
+
+하지만 현재 재료까지의 칼로리 합이 제한 칼로리보다 높다면 더 이상 탐색할 필요가 없으므로 넘어간다.
+
+### 코드
+
+```py
+test_case = int(input())
+
+
+# 제한 칼로리 내에서 최대의 맛
+def search_best(hamburgers, sum_cal=0, sum_score=0):
+    global max_score
+    max_score = max(max_score, sum_score)
+
+    for i, (score, cal) in enumerate(hamburgers):
+        if sum_cal + cal > l:
+            continue
+        search_best(hamburgers[i + 1:], sum_cal + cal, sum_score + score)
+
+
+for t in range(test_case):
+    n, l = map(int, input().split())
+
+    hamburgers = [list(map(int, input().split())) for _ in range(n)]
+
+    max_score = 0
+
+    search_best(hamburgers)
+
+    print(f"#{t + 1} {max_score}")
+```
+
+## DP를 활용한 풀이
+
+이 문제를 다시 생각해보면 재료를 고르거나(1) 안고르면서(0) 주어진 칼로리(용량) 내에서 최대의 점수(이득)을 얻는 것이 목적이므로, 0-1 배낭 문제와 동일하다.
+
+이에 이전까지의 맛 점수의 최대치를 활용하여, 칼로리 제한 `l`에서 내려가며 가장 높은 점수를 계산한다.
+말로 하니 어려우니 아래 예시를 보자.
+
+DP를 위한 점화식은 다음과 같디.
+```py
+dp = [0] * (l + 1)
+...
+dp[j] = max(dp[j], dp[j - cal] + score)
+```
+이 점화식을 아래 예시 입력으로 연산을 진행해보자.
+
+```bash
+1
+5 1000
+100 200
+300 500
+250 300
+500 1000
+400 400
+```
+
+첫 입력은 점수 100, 칼로리 200의 재료이다. (편의상 100 단위로 인덱스를 표시했지만 실제로는 1단위이다.)
+
+
+|score|cal|
+|---|---|
+|100|200|
+
+|**$j$**    |1000|900|800|700|600|500|400|300|200|100|0|
+|:---------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+|$j-cal$    |800|700|600|500|400|300|200|100|0|-|-|
+|$DP_{before}$|0|0|0|0|0|0|0|0|0|0|0|
+|$DP_{next}$|100|100|100|100|100|100|100|100|100|0|0|
+
+점화식에 따라 현재 인덱스의 (dp 배열 값)과 (`j - cal` 인덱스 값 + 현재 `score` 값) 중 큰 값을 취한다.
+
+즉, 지금까지 저장한 현재 위치의 칼로리 `j`와 (`score` + `j-cal`) 칼로리로 만들 수 있는 맛 점수를 비교하는 것이다.
+
+한 스탭 더 진행해보자.
+
+|score|cal|
+|---|---|
+|300|500|
+
+|**$j$**    |1000|900|800|700|600|500|400|300|200|100|0|
+|:---------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+|$j-cal$    |500|400|300|200|100|0|-|-|-|-|-|
+|$DP_{before}$|100|100|100|100|100|100|100|100|100|0|0|
+|$DP_{next}$|400|400|400|400|300|300|100|100|100|0|0|
+
+`j`가 1000 ~ 700일 때까지는 기존 DP 배열의 인덱스 500 ~ 200까지의 값과 합하여 기존 값과 비교한다. 비교 결과 새로운 값이 더 크기 때문에 400(100 + 300)으로 갱신한다. `j`가 600 ~ 500일 때도 마찬가지로 진행하지만 기존 값이 0이기 때문에 300(0 + 300)으로 갱신한다.
+
+이후에도 같은 과정으로 진행한다.
+
+|score|cal|
+|---|---|
+|250|300|
+
+|**$j$**    |1000|900|800|700|600|500|400|300|200|100|0|
+|:---------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+|$j-cal$    |700|600|500|400|300|200|100|0|-|-|-|
+|$DP_{before}$|400|400|400|400|300|300|100|100|100|0|0|
+|$DP_{next}$|650|550|550|400|350|350|250|250|100|0|0|
+
+|score|cal|
+|---|---|
+|500|1000|
+
+|**$j$**    |1000|900|800|700|600|500|400|300|200|100|0|
+|:---------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+|$j-cal$    |0|-|-|-|-|-|-|-|-|-|-|
+|$DP_{before}$|650|550|550|400|350|350|250|250|100|0|0|
+|$DP_{next}$|650|550|550|400|350|350|250|250|100|0|0|
+
+|score|cal|
+|---|---|
+|400|400|
+
+|**$j$**    |1000|900|800|700|600|500|400|300|200|100|0|
+|:---------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+|$j-cal$    |600|500|400|300|200|100|0|-|-|-|-|
+|$DP_{before}$|650|550|550|400|350|350|250|250|100|0|0|
+|$DP_{next}$|750|750|650|650|500|400|400|250|100|0|0|
+
+마지막 시행이 끝난 후 DP 배열에서 최대값을 출력한다.
+
+### 코드
+
+```python
+test_case = int(input())
+
+for t in range(test_case):
+    n, l = map(int, input().split())
+
+    hamburgers = [list(map(int, input().split())) for _ in range(n)]
+
+    dp = [0] * (l + 1)
+
+    for score, cal in hamburgers:
+        for j in range(l, cal - 1, -1):
+            dp[j] = max(dp[j], dp[j - cal] + score)
+
+    max_score = max(dp)
+
+    print(f"#{t + 1} {max_score}")
+```
\ No newline at end of file
diff --git a/_posts/2024-08-06-swea_4012.markdown b/_posts/2024-08-06-swea_4012.markdown
new file mode 100644
index 00000000000..9da40631e21
--- /dev/null
+++ b/_posts/2024-08-06-swea_4012.markdown
@@ -0,0 +1,144 @@
+---
+title: "[SWEA]요리사 - 4012 (모의 역량 테스트)"
+author: kwon
+date: 2024-08-06T14:00:00 +0900
+categories: [swea, 모의역량]
+tags: [combinatorics, backtracking]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 10 초 | 힙 정적 메모리: 256 MB / 스택 메모리 1MB |
+
+# 문제
+
+
+두 명의 손님에게 음식을 제공하려고 한다.
+
+두 명의 손님은 식성이 비슷하기 때문에, 최대한 비슷한 맛의 음식을 만들어 내야 한다.
+
+N개의 식재료가 있다.
+
+식재료들을 각각 N / 2개씩 나누어 두 개의 요리를 하려고 한다. (N은 짝수이다.)
+
+이때, 각각의 음식을 A음식, B음식이라고 하자.
+
+비슷한 맛의 음식을 만들기 위해서는 A음식과 B음식의 맛의 차이가 최소가 되도록 재료를 배분해야 한다.
+
+음식의 맛은 음식을 구성하는 식재료들의 조합에 따라 다르게 된다.
+
+ 
+
+식재료 i는 식재료 j와 같이 요리하게 되면 궁합이 잘 맞아 시너지 Sij가 발생한다. (1 ≤ i ≤ N, 1 ≤ j ≤ N, i ≠ j)
+
+각 음식의 맛은 음식을 구성하는 식재료들로부터 발생하는 시너지 Sij들의 합이다.
+
+ 
+
+식재료 i를 식재료 j와 같이 요리하게 되면 발생하는 시너지 Sij의 정보가 주어지고, 가지고 있는 식재료를 이용해 A음식과 B음식을 만들 때, 두 음식 간의 맛의 차이가 최소가 되는 경우를 찾고 그 최솟값을 정답으로 출력하는 프로그램을 작성하라.
+
+ 
+자세한 예시는 [여기로](https://swexpertacademy.com/main/talk/solvingClub/problemView.do?solveclubId=AZC_w6Z6yygDFAQW&contestProbId=AWIeUtVakTMDFAVH&probBoxId=AZDJUP6q-fgDFAVs&type=PROBLEM&problemBoxTitle=2d_recommend&problemBoxCnt=2&&&&&&).
+
+## 제약 사항
+
+1. 시간 제한 : 최대 50개 테스트 케이스를 모두 통과하는 데 C / C++ / Java 모두 3초
+
+2. 식재료의 수 N은 4이상 16이하의 짝수이다. $(4 ≤ N ≤ 16)$
+
+3. 시너지 Sij는 1이상 20,000이하의 정수이다. $(1 ≤ Sij ≤ 20,000, i ≠ j)$
+
+4. i와 j가 서로 같은 경우의 Sij값은 정의되지 않는다. 입력에서는 0으로 주어진다.
+
+# 입력
+
+입력의 맨 첫 줄에는 총 테스트 케이스의 개수 T가 주어지고,
+
+그 다음 줄부터 T개의 테스트 케이스가 주어진다.
+
+각 테스트 케이스의 첫 번째 줄에는 식재료의 수 N이 주어진다.
+
+다음 N개의 줄에는 N * N개의 시너지 Sij값들이 주어진다. i와 j가 서로 같은 경우는 0으로 주어진다.
+
+# 출력
+
+테스트 케이스 개수만큼 T개의 줄에 각각의 테스트 케이스에 대한 답을 출력한다.
+
+각 줄은 "#t"로 시작하고 공백을 하나 둔 다음 정답을 출력한다. (t 는 1부터 시작하는 테스트 케이스의 번호이다.)
+
+정답은 두 음식 간의 맛의 차이가 최소가 되도록 A음식과 B음식을 만들었을 때 그 차이 값이다.
+
+# 풀이
+
+주어진 재료의 절반씩 사용하여 요리를 만들어 두 요리의 맛 차이가 최소로 되도록 하는 문제이다.
+
+이 댸 재료의 절반을 사용하는 것을 다음과 같은 조합으로 나타낼 수 있다.
+
+$$
+{N}\choose{N//2}
+$$
+
+두 요리에 대한 재료를 모두 구해야 하나? 하고 생각할 수 있지만, 한 요리의 재료가 결정되면 나머지 하나의 재료는 결정되기 때문에 굳이 구할 필요는 없다.     
+
+그래서 `range(1, n)`에 대해 `n // 2` 개의 원소를 가지는 조합을 구하도록 `search_recipe`를 작성하였다. 이후 전체 집합에 대해 차집합하여 반대쪽 조합을 구한다.
+
+```py
+...
+        comb2 = list(index_set - set(comb))
+...
+```
+
+구해진 조합으로 맛을 계산하고 차이의 최솟값을 구하면 된다.
+
+```py
+...
+        for i_idx, (i1, i2) in enumerate(zip(comb, comb2)):
+            for j1, j2 in zip(comb[i_idx + 1:], comb2[i_idx + 1:]):
+                food1 += recipe[i1][j1] + recipe[j1][i1]
+                food2 += recipe[i2][j2] + recipe[j2][i2]
+        min_diff = min(min_diff, abs(food1 - food2))
+...
+```
+
+만들어준 조합 배열의 맨 앞에 `[0]`을 붙여주는 이유는 주어진 재료의 번호가 1부터 시작하기 때문에 인덱스와 맞춰주기 위함이다.
+
+## 코드
+
+```py
+test_case = int(input())
+
+def search_recipe(index_list, n):
+    if n == 1 :
+        return [[i] for i in index_list]
+    result = []
+    for i in range(len(index_list) - 1):
+        for j in search_recipe(index_list[i+1:], n - 1):
+            result.append([index_list[i]] + j)
+    
+    return result
+
+
+for t in range(test_case):
+    n = int(input())
+    min_diff = float('inf')
+
+    recipe = [list(map(int, input().split())) for _ in range(n)]
+    
+    index_set = set(range(n))
+
+    comb_list = [[0] + c for c in search_recipe(list(range(1, n)), n // 2 - 1)]
+
+    for comb in comb_list:
+        comb2 = list(index_set - set(comb))
+        food1, food2 = 0, 0
+
+        for i_idx, (i1, i2) in enumerate(zip(comb, comb2)):
+            for j1, j2 in zip(comb[i_idx + 1:], comb2[i_idx + 1:]):
+                food1 += recipe[i1][j1] + recipe[j1][i1]
+                food2 += recipe[i2][j2] + recipe[j2][i2]
+        min_diff = min(min_diff, abs(food1 - food2))
+
+    print(f"#{t + 1} {min_diff}")
+```
\ No newline at end of file
diff --git a/_posts/2024-08-09-swea_4008.markdown b/_posts/2024-08-09-swea_4008.markdown
new file mode 100644
index 00000000000..cae75760042
--- /dev/null
+++ b/_posts/2024-08-09-swea_4008.markdown
@@ -0,0 +1,136 @@
+---
+title: "[SWEA]숫자 만들기 - 4008 (모의 역량 테스트)"
+author: kwon
+date: 2024-08-09T14:00:00 +0900
+categories: [swea, 모의역량]
+tags: [dfs]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 10 초 | 힙 정적 메모리: 256 MB / 스택 메모리 1MB |
+
+# 문제
+
+
+선표는 게임을 통해 사칙 연산을 공부하고 있다.
+
+N개의 숫자가 적혀 있는 게임 판이 있고, +, -, x, / 의 연산자 카드를 숫자 사이에 끼워 넣어 다양한 결과 값을 구해보기로 했다.
+
+수식을 계산할 때 연산자의 우선 순위는 고려하지 않고 왼쪽에서 오른쪽으로 차례대로 계산한다.
+
+예를 들어 1, 2, 3 이 적힌 게임 판에 +와 x를 넣어 1 + 2 * 3을 만들면 1 + 2를 먼저 계산하고 그 뒤에 * 를 계산한다.
+
+즉 1+2*3의 결과는 9이다.
+
+ 
+주어진 연산자 카드를 사용하여 수식을 계산했을 때 그 결과가 최대가 되는 수식과 최소가 되는 수식을 찾고, 두 값의 차이를 출력하시오.
+
+ 
+자세한 예시는 [여기로](https://swexpertacademy.com/main/talk/solvingClub/problemView.do?solveclubId=AZC_w6Z6yygDFAQW&contestProbId=AWIeRZV6kBUDFAVH&probBoxId=AZC_w6Z6yykDFAQW&type=PROBLEM&problemBoxTitle=1w_homework&problemBoxCnt=5)
+
+## 제약 사항
+
+1. 시간 제한 : 최대 50 개 테스트 케이스를 모두 통과하는 데 C / C++ / Java 모두 3 초
+
+2. 게임 판에 적힌 숫자의 개수 N 은 3 이상 12 이하의 정수이다. ( 3 ≤ N ≤ 12 )
+
+3. 연산자 카드 개수의 총 합은 항상 N - 1 이다.
+
+4. 게임 판에 적힌 숫자는 1 이상 9 이하의 정수이다.
+
+5. 수식을 완성할 때 각 연산자 카드를 모두 사용해야 한다..
+
+6. 숫자와 숫자 사이에는 연산자가 1 개만 들어가야 한다.
+
+7. 완성된 수식을 계산할 때 연산자의 우선 순위는 고려하지 않고, 왼쪽에서 오른쪽으로 차례대로 계산한다.
+
+8. 나눗셈을 계산 할 때 소수점 이하는 버린다.
+
+9. 입력으로 주어지는 숫자의 순서는 변경할 수 없다.
+
+10. 연산 중의 값은 -100,000,000 이상 100,000,000 이하임이 보장된다.
+
+# 입력
+
+입력의 맨 첫 줄에는 총 테스트 케이스의 개수 T 가 주어지고,
+
+그 다음 줄부터 T 개의 테스트 케이스가 주어진다.
+
+각 테스트 케이스의 첫 번째 줄에는 숫자의 개수 N 이 주어진다.
+
+다음 줄에는 '+', '-', '*', '/' 순서대로 연산자 카드의 개수가 공백을 사이에 두고 주어진다.
+
+다음 줄에는 수식에 들어가는 N 개의 숫자가 순서대로 공백을 사이에 두고 주어진다.
+
+# 출력
+
+테스트 케이스 개수만큼 T 개의 줄에 각각의 테스트 케이스에 대한 답을 출력한다.
+
+각 줄은 "#t" 로 시작하고 공백을 하나 둔 다음 정답을 출력한다. ( t 는 1 부터 시작하는 테스트 케이스의 번호이다. )
+
+정답은 연산자 카드를 사용하여 만들 수 있는 수식으로 얻은 결과값 중 최댓값과 최솟값의 차이이다.
+
+# 풀이
+
+주어진 숫자 사이에 주어진 연산자를 넣어 수를 계산하고, 그 수의 최대와 최소의 차이를 출력하는 문제이다.
+
+무심코 풀이를 생각하면 받은 연산자를 모든 위치에 넣어가면서 계산하면 되는 것이 아닌가 할 수 있지만, 이 경우 중복 계산이 빈번하게 발생할 수 있다.
+
+예를 들어 + + + 로 연산자가 주어진다면 어떤 경우이든 같은 값이 나올 것이다. 하지만 연산자를 모든 위치에 넣어가면서 계산할 경우 $3 * 2 * 1 = 6$ 번의 중복 계산을 하게 된다.
+
+이런 경우를 방지하기 위해 연산자의 수를 세는 딕셔너리를 만들고, 몇 번 사용했는지 확인하였다. 이렇게 하면 각 연산자마다 다른 것으로 생각하지 않기 때문에 위에서 언급한 중복 연산을 없앨 수 있다.
+
+## 코드
+
+```py
+# 계산
+
+def calculate(num1, num2, operator):
+
+    if operator == '+':
+        num1 += num2
+    elif operator == '-':
+        num1 -= num2
+    elif operator == '*':
+        num1 *= num2
+    elif operator == '/':
+        num1 = int(num1 / num2)
+    return num1
+
+# 수식 완성
+def search_expression(i, result):
+    if i == n:
+        global max_num, min_num
+        max_num = max(max_num, result)
+        min_num = min(min_num, result)
+        return
+
+    for operator in operators:
+        if operator_dict[operator] > 0:
+            operator_dict[operator] -= 1
+            search_expression(i + 1, calculate(result, nums[i+1], operator))
+            operator_dict[operator] += 1
+
+
+
+test_case = int(input())
+
+for t in range(test_case):
+    n = int(input()) - 1
+    operators = ['+', '-', '*', '/']
+    operator_dict = {operator: cnt for operator, cnt in zip(operators, map(int, input().split()))}
+
+    nums = list(map(int, input().split()))
+
+    max_num = float('-inf')
+    min_num = float('inf')
+    result_dict = {}
+    visited = []
+
+    search_expression(0, nums[0])
+
+    print(f"#{t + 1} {max_num - min_num}")
+```
\ No newline at end of file
diff --git a/_posts/2024-08-10-swea_2115.markdown b/_posts/2024-08-10-swea_2115.markdown
new file mode 100644
index 00000000000..b2a66a7d8d7
--- /dev/null
+++ b/_posts/2024-08-10-swea_2115.markdown
@@ -0,0 +1,189 @@
+---
+title: "[SWEA]벌꿀 채취 - 2115 (모의 역량 테스트)"
+author: kwon
+date: 2024-08-10T14:00:00 +0900
+categories: [swea, 모의역량]
+tags: [dfs, subset, dynamic programing]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 6 초 | 힙 정적 메모리: 256 MB / 스택 메모리 1MB |
+
+# 문제
+
+
+N*N 개의 벌통이 정사각형 모양으로 배치되어 있다.
+
+각 칸의 숫자는 각각의 벌통에 있는 꿀의 양을 나타내며, 꿀의 양은 서로 다를 수 있다.
+
+각 벌통에 있는 꿀의 양이 주어졌을 때, 다음과 같은 과정으로 벌꿀을 채취하여 최대한 많은 수익을 얻으려고 한다.
+
+1.  두 명의 일꾼이 있다. 꿀을 채취할 수 있는 벌통의 수 M이 주어질 때, 
+    각각의 일꾼은 가로로 연속되도록 M개의 벌통을 선택하고, 선택한 벌통에서 꿀을 채취할 수 있다.
+    단, 두 명의 일꾼이 선택한 벌통은 서로 겹치면 안 된다. 
+
+2.  두 명의 일꾼은 선택한 벌통에서 꿀을 채취하여 용기에 담아야 한다.
+    단, 서로 다른 벌통에서 채취한 꿀이 섞이게 되면 상품가치가 떨이지게 되므로, 하나의 벌통에서 채취한 꿀은 하나의 용기에 담아야 한다.
+    하나의 벌통에서 꿀을 채취할 때, 일부분만 채취할 수 없고 벌통에 있는 모든 꿀을 한번에 채취해야 한다.
+    두 일꾼이 채취할 수 있는 꿀의 최대 양은 C 이다.
+
+3.  채취한 꿀은 시장에서 팔리게 된다. 이때 하나의 용기에 있는 꿀의 양이 많을수록 상품가치가 높아, 각   용기에 있는 꿀의 양의 제곱만큼의 수익이 생긴다.
+
+
+벌통들의 크기 N과 벌통에 있는 꿀의 양에 대한 정보, 선택할 수 있는 벌통의 개수 M, 꿀을 채취할 수 있는 최대 양 C가 주어진다.
+
+이때 두 일꾼이 꿀을 채취하여 얻을 수 있는 수익의 합이 최대가 되는 경우를 찾고, 그 때의 최대 수익을 출력하는 프로그램을 작성하라.
+
+## 제약 사항
+
+1. 시간제한 : 최대 50개 테스트 케이스를 모두 통과하는데, C/C++/Java 모두 3초.
+
+2. 벌통들의 크기 N은 3 이상 10 이하의 정수이다. (3 ≤ N ≤ 10)
+
+3. 선택할 수 있는 벌통의 개수 M은 1 이상 5 이하의 정수이다. (1 ≤ M ≤ 5)
+
+4. 선택할 수 있는 벌통의 개수 M은 반드시 N 이하로만 주어진다.
+
+5. 꿀을 채취할 수 있는 최대 양 C는 10 이상 30 이하의 정수이다. (10 ≤ C ≤ 30)
+
+6. 하나의 벌통에서 채취할 수 있는 꿀의 양은 1 이상 9 이하의 정수이다.
+
+7. 하나의 벌통에서 일부분의 꿀만 채취할 수 없고, 벌통에 있는 모든 꿀을 한번에 채취해야 한다.
+
+# 입력
+
+입력의 맨 첫 줄에는 총 테스트 케이스의 개수 T가 주어지고, 그 다음 줄부터 T개의 테스트 케이스가 주어진다.
+
+각 테스트 케이스의 첫 번째 줄에는 벌통들의 크기 N, 선택할 수 있는 벌통의 개수 M, 꿀을 채취할 수 있는 최대 양 C가 차례로 주어진다.
+
+그 다음 줄부터 N*N 개의 벌통에서 채취할 수 있는 꿀의 양에 대한 정보가 주어진다.
+
+# 출력
+
+테스트 케이스의 개수만큼 T줄에 T개의 테스트 케이스 각각에 대한 답을 출력한다.
+
+각 줄은 "#x"로 시작하고 공백을 하나 둔 다음 정답을 출력한다. (x는 1부터 시작하는 테스트 케이스의 번호이다)
+
+출력해야 할 정답은 두 일꾼이 꿀을 채취하여 얻을 수 있는 최대 수익이다.
+
+# 풀이
+
+일종의 완전탐색을 기반으로 가지치기를 해야 한다고 생각했다.
+
+두 사람이 벌통을 선택할 수 있는 방법을 모두 탐색하는 것을 기반으로 진행한다. 탐색하면서 고른 벌통에 대해 부분집합을 만들어 제곱의 합이 최대가 되는 경우를 찾는다. 최대가 되는 제곱의 합이 바로 고른 벌통들에서 나올 수 있는 최대 수익이 된다.
+
+이 때 꿀의 양이 `c`를 넘는 경우는 더 이상 부분 집합을 만들 필요가 없기 때문에 연산하지 않는다.
+
+## 재귀를 통한 풀이
+
+첫 번째로 생각한 방법은 재귀로 부분 집합을 그대로 구해서 계산하는 것이다. 단, 앞서 말한 가지치기를 하기 위해 `c`를 넘는 경우는 넘어가도록 작성하였다.
+
+### 코드
+
+```py
+test_case = int(input())
+
+def make_subset(arr, depth, honey_num = 0, selected = []):
+    if depth == -1:
+        subsets.append(selected)
+        return
+    for i in range(2):
+        if i == 0:
+            make_subset(arr, depth - 1, honey_num, selected)
+        else:
+            if honey_num + arr[depth] > c:
+                continue
+            make_subset(arr, depth - 1, honey_num + arr[depth], selected + [arr[depth]])
+
+def calcul_max_cost(subsets):
+    max_cost = 0
+    for subset in subsets:
+        cost = 0
+        for ele in subset:
+            cost += ele ** 2
+
+        max_cost = max(max_cost, cost)
+
+    return max_cost
+
+for t in range(test_case):
+    n, m, c = map(int, input().split())
+    honey_map = [list(map(int, input().split())) for _ in range(n)]
+    total_max = 0
+
+    for fst_i in range(n):
+        for fst_j in range(n - m + 1):
+
+            subsets = []
+            make_subset(honey_map[fst_i][fst_j:fst_j + m], m - 1)
+            fst_max = calcul_max_cost(subsets)
+
+            for snd_i in range(n):
+                start = 0
+                if snd_i == fst_i:
+                    start = fst_j + m
+                for snd_j in range(start, n - m + 1):
+                    subsets = []
+                    make_subset(honey_map[snd_i][snd_j:snd_j + m], m - 1)
+                    snd_max = calcul_max_cost(subsets)
+
+                    total_max = max(total_max, fst_max + snd_max)
+
+    print(f"#{t + 1} {total_max}")
+```
+
+## DP를 통한 풀이
+
+이 문제를 다시 잘 생각해보면 선택한 꿀통 내에서 꿀통을 고르거나(1) 안고르면서(0) 주어진 `c`(용량) 내에서 최대의 수익(이득)을 얻는 것이 목적이다. 즉, 이 문제는 0-1 배낭 문제와 유사하므로 DP로도 풀이할 수 있다.
+
+이전에 푼 [햄버거 다이어트](/posts/swea_5215/)에서 사용한 DP의 진행 방식과 유사하게 수익을 찾는 풀이이다.
+
+다른 점은 꿀 양의 합이 `c`를 넘을 경우 DP에 반영하지 않는다는 것과, 제곱의 합이 큰 것을 기준으로 PD에 업데이트한다는 것이다.
+
+부분 집합을 만들어 수익을 계산하는 부분이 DP로 바뀐 것만 제외하면 재귀를 통한 풀이와 완전히 동일하다.
+
+```py
+def max_subset_sum(arr):
+    dp = [[0, 0] for _ in range(c + 1)]
+
+    for num in arr:
+        for j in range(c, num - 1, -1):
+            if dp[j - num][0] + num > c:
+                continue
+            next_sq_value = dp[j - num][1] + num ** 2
+            if next_sq_value > dp[j][1]:
+                dp[j][0] = dp[j - num][0] + num
+                dp[j][1] = next_sq_value
+    _, max_sum = max(dp, key=lambda x: x[1])
+    return max_sum
+
+test_case = int(input())
+
+for t in range(test_case):
+    n, m, c = map(int, input().split())
+    honey_map = [list(map(int, input().split())) for _ in range(n)]
+    total_max = 0
+
+    for fst_i in range(n):
+        for fst_j in range(n - m + 1):
+
+            fst_max = max_subset_sum(honey_map[fst_i][fst_j:fst_j + m])
+
+            for snd_i in range(n):
+                start = 0
+                if snd_i == fst_i:
+                    start = fst_j + m
+                for snd_j in range(start, n - m + 1):
+                    snd_max = max_subset_sum(honey_map[snd_i][snd_j:snd_j + m])
+
+                    total_max = max(total_max, fst_max + snd_max)
+
+    print(f"#{t + 1} {total_max}")
+```
+
+근데 생각보다 실행 시간이 **Dynamic**하게 줄어들지 않아 살짝 김샜다.
+
+![](/posting_imgs/swea2115.png)
\ No newline at end of file
diff --git a/_posts/2024-08-14-swea_2112.markdown b/_posts/2024-08-14-swea_2112.markdown
new file mode 100644
index 00000000000..f16f7722269
--- /dev/null
+++ b/_posts/2024-08-14-swea_2112.markdown
@@ -0,0 +1,177 @@
+---
+title: "[SWEA]보호 필름 - 2112 (모의 역량 테스트)"
+author: kwon
+date: 2024-08-14T14:00:00 +0900
+categories: [swea, 모의역량]
+tags: [dfs, backtracking]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 15 초 | 힙 정적 메모리: 256 MB / 스택 메모리 1MB |
+
+# 문제
+
+성능이 우수한 보호 필름을 제작하려고 한다.
+
+보호 필름은 엷은 투명한 막을 D장 쌓아서 제작된다.
+
+막은 동일한 크기를 가진 바(bar) 모양의 셀들이 가로 방향으로 W개 붙여서 만들어진다.
+
+이렇게 제작된 필름은 두께 D, 가로 크기 W의 보호 필름이라고 한다.
+
+
+
+각 셀들은 특성 A 또는 특성 B를 가지고 있다. 보호 필름의 성능은 셀들의 특성이 어떻게 배치됨에 따라 결정된다.
+
+
+보호 필름의 성능을 검사하기 위해 합격기준 K라는 값을 사용한다.
+
+충격은 보호 필름 단면의 세로 방향으로 가해지므로, 세로 방향 셀들의 특성이 중요하다.
+
+단면의 모든 세로방향에 대해서 동일한 특성의 셀들이 K개 이상 연속적으로 있는 경우에만 성능검사를 통과하게 된다.
+
+
+성능검사에 통과하기 위해서 약품을 사용하여야 한다.
+
+약품은 막 별로 투입할 수 있으며 이 경우 투입하는 막의 모든 셀들은 하나의 특성으로 변경된다.
+
+특정 막에 약품 A를 투입하면 막 내의 모든 셀들이 특성 A로 변경되며, 약품 B를 넣게 되면 특성이 모두 특성 B로 변경된다.
+
+
+두께 D, 가로크기 W인 보호 필름 단면의 정보와 합격기준 K가 주어졌을 때, 약품 투입 횟수를 최소로 하여 성능검사를 통과할 수 있는 방법을 찾고,
+
+이때의 약품 투입 횟수를 출력하라.
+
+약품을 투입하지 않고도 성능검사를 통과하는 경우에는 0을 출력한다.
+
+
+## 제약사항
+
+1. 시간제한 : 최대 50개 테스트 케이스를 모두 통과하는데, C/C++/Java 모두 5초
+
+2. 보호 필름의 두께 D는 3이상 13이하의 정수이다. (3≤D≤13)
+
+3. 보호 필름의 가로크기 W는 1이상 20이하의 정수이다. (1≤W≤20)
+
+4. 합격기준 K는 1이상 D이하의 정수이다. (1≤K≤D)
+
+5. 셀이 가질 수 있는 특성은 A, B 두 개만 존재한다.
+
+
+# 입력
+
+첫 줄에 총 테스트 케이스의 개수 T가 주어진다.
+
+두 번째 줄부터 T개의 테스트 케이스가 차례대로 주어진다.
+
+각 테스트 케이스의 첫 줄에는 보호 필름의 두께 D, 가로크기 W, 합격기준 K가 차례로 주어진다.
+
+그 다음 D줄에 보호 필름 단면의 정보가 주어진다. 각 줄에는 셀들의 특성 W개가 주어진다. (특성A는 0, 특성B는 1로 표시된다.)
+
+
+# 출력
+
+테스트 케이스의 개수만큼 T줄에 T개의 테스트 케이스 각각에 대한 답을 출력한다.
+
+각 줄은 “#x”로 시작하고 공백을 하나 둔 다음 정답을 출력한다. (x는 1부터 시작하는 테스트 케이스의 번호이다)
+
+출력해야 할 정답은 성능검사를 통과할 수 있는 약품의 최소 투입 횟수이다. 약품을 투입하지 않고도 성능검사를 통과하는 경우에는 0을 출력한다.
+
+# 풀이
+
+DFS를 통해 각 층 마다 약품 A 혹은 B를 투입하거나, 투입하지 않는 경우를 탐색했다.
+
+그리고 각 탐색마다 테스트를 통과할 수 있는지 확인하여, 통과할 수 있다면 최소 주입 횟수를 갱신하고 탐색을 중단한다.
+
+## `test_film()`
+
+보호 필름 테스트는 세로로 연속하는 특성을 찾아햐 한다.
+
+```py
+def chk_test():
+    chk_a_list = [0] * k
+    chk_b_list = [1] * k
+
+    for w_i in range(w):
+        is_success = False
+
+        for d_i in range(d - k + 1):
+            cur_chk = [film[tmp_i][w_i] for tmp_i in range(d_i, d_i + k)]
+            if cur_chk == chk_a_list or cur_chk == chk_b_list:
+                is_success = True
+                break
+        if not is_success:
+            return False
+    return True
+```
+
+그래서 위와 같이 `k`만큼 세로로 배열을 만들어 같은 값으로 연속하는 지 확인한다. (`[film[tmp_i][w_i] for tmp_i in range(d_i, d_i + k)]`)
+
+## 코드
+
+```py
+test_case = int(input())
+
+def chk_test():
+    chk_a_list = [0] * k
+    chk_b_list = [1] * k
+
+    for w_i in range(w):
+        is_success = False
+
+        for d_i in range(d - k + 1):
+            cur_chk = [film[tmp_i][w_i] for tmp_i in range(d_i, d_i + k)]
+            if cur_chk == chk_a_list or cur_chk == chk_b_list:
+                is_success = True
+                break
+        if not is_success:
+            return False
+    return True
+
+
+def test_film(film, depth=0, cnt_inject=0, chk_list=[]):
+    global min_inject
+    
+    if cnt_inject >= min_inject:
+        return
+
+    if chk_test():
+        min_inject = min(min_inject, cnt_inject)
+        return
+
+    if depth >= d:
+        return
+    
+    origin_membrane = film[depth][:]
+
+    # 현재 층을 그대로
+    test_film(film, depth + 1, cnt_inject)
+
+    # 현재 층을 a로
+    film[depth] = inject_a
+    test_film(film, depth + 1, cnt_inject + 1)
+    film[depth] = origin_membrane
+
+    # 현재 층을 b로
+    film[depth] = inject_b
+    test_film(film, depth + 1, cnt_inject + 1)
+    film[depth] = origin_membrane
+
+for t in range(test_case):
+    d, w, k = map(int, input().split())
+
+    film = [list(map(int, input().split())) for _ in range(d)]
+    
+    inject_a = [0] * w
+    inject_b = [1] * w
+
+    min_inject = float('inf')
+
+    test_film(film)
+    print(f"#{t + 1} {min_inject}")
+```
+
+DFS를 진행하면서 지금의 필름(`film`), 깊이(`depth`), 투입한 횟수(`cnt_inject`)를 넘겨준다. 이 때 약물을 투입했다면, 재귀가 끝난 후 원래 상태로 돌려준다.
\ No newline at end of file
diff --git a/_posts/2024-09-09-boj_14712.markdown b/_posts/2024-09-09-boj_14712.markdown
new file mode 100644
index 00000000000..2d3d514ebd3
--- /dev/null
+++ b/_posts/2024-09-09-boj_14712.markdown
@@ -0,0 +1,89 @@
+---
+title: "[BOJ]넴모넴모 (Easy) - 14712 (G5)"
+author: kwon
+date: 2024-09-09T14:00:00 +0900
+categories: [boj, gold]
+tags: [brute-force, backtracking]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 1 초 | 512 MB |
+
+# 문제
+
+네모는 뿌××× 게임에 깊은 감명을 받아, 직사각형 모양의 격자판과 "넴모"라는 수수께끼의 생물을 이용하는 "넴모"모”라는 게임을 만들었다. 이 게임의 규칙은 아주 간단하다. 격자판의 비어 있는 칸을 임의로 골라 "넴모"를 하나 올려놓거나, "넴모"가 올라간 칸 네 개가 2 × 2 사각형을 이루는 부분을 찾아 그 위에 있는 "넴모"들을 모두 없애는 것을 질릴 때까지 반복하면 된다.
+
+하지만 안타깝게도 게임은 정말 재미가 없었고, 네모는 아주 빨리 질려 버리고 말았다. 실망한 네모는 게임을 적당히 플레이하다가, "넴모"를 없애고 싶은데 격자판 위에 없앨 수 있는 "넴모"가 없으면 게임을 그만두기로 했다. 네모가 게임을 그만두었을 때 나올 수 있는 "넴모"의 배치의 가짓수를 구하여라.
+
+# 입력
+
+첫 번째 줄에 격자판의 행의 개수 N, 열의 개수 M(1 ≤ N, M ≤ 25, 1 ≤ N × M ≤ 25)이 공백으로 구분되어 주어진다.
+
+# 출력
+
+첫 번째 줄에 주어진 격자판에서 나올 수 있는, "넴모"들이 올라간 칸이 2 × 2 사각형을 이루지 않는 모든 배치의 가짓수를 출력한다.
+
+# 힌트
+
+2×2 격자판에 2×2 사각형을 이루지 않도록 "넴모"들을 배치하는 방법은 모든 경우(24 = 16) 중 네 칸 모두에 "넴모"가 올라가 있는 경우를 제외한 15가지가 있다.
+
+# 풀이
+
+DFS 기반의 백트래킹으로 풀었다.
+기본적인 DFS 수행은 x축 방향으로 진행하면서 넴모를 놓거나 놓지 않는 방식으로 진행한다.
+
+하지만 굳이 사각형이 완성되는 경우까지 넴모를 놓을 필요는 없으므로 그런 경우는 제외하고 탐색한다.
+
+사각형이 완성되는 것은 현재 위치에서 **좌상, 좌, 우**에 있는 칸을 확인하면 알 수 있다.
+만약 다음 그림과 같이 우하, 우, 하에 있는 칸을 확인하면 다음에 놓을 넴모를 미리 알 수 없어 사각형이 완성되는지 확인하기 곤란하다.
+
+![boj_14712-1](/posting_imgs/boj_14712-1.png){: width="40%"}
+
+그래서 아래와 같이 **좌상, 좌, 우**를 확인하면서 x축 방향으로 넴모를 놓거나 놓지 않게 탐색을 진행한다.
+
+![boj_14712-2](/posting_imgs/boj_14712-2.png){: width="40%"}
+
+## 사방 탐색이 힘든 이유
+
+그냥 우리 많이 하는 것처럼 사방 탐색으로 해버리면 안되냐, 할 수 있다.
+하지만 x축 방향으로 차례대로 진행하지 않으면, 위에서 언급한 우하, 우, 하로 사각형을 확인할 때와 같은 문제가 발생한다.
+
+아직 탐색하지 못한(넴모를 놓거나 놓지 못한) 칸에 대해 우리가 사각형인지 판별할 수 없기 때문이다. 그래서 x축 방향(글 쓰는 방향)으로 탐색하면서 이미 탐색이 끝난 칸에 대해서만 사각형을 판별하도록 만들고, 모든 경우에 대해 제대로 넴모를 놓을 수 있게 된다.
+
+## 코드
+
+```python
+def fill_nemo(d=0):
+    global cnt
+    if N*M == d:
+        cnt += 1
+        return
+    
+    y = d // M + 1
+    x = d  % M + 1
+
+    # 사각형이 완성 안되는 경우(넴모를 놓을 수 있는 경우)
+    if matrix[y-1][x] == 0 or matrix[y-1][x-1] == 0 or matrix[y][x-1] == 0:
+        # 다음 위치에 네모 생성
+        matrix[y][x] = 1
+        fill_nemo(d+1)
+        matrix[y][x] = 0
+
+    # 다음 위치에 네모 생성 X
+    fill_nemo(d+1)
+    
+
+N, M = map(int, input().split())
+
+matrix = [[0]*(M+1) for _ in range(N+1)]
+
+cnt = 0
+fill_nemo()
+
+print(cnt)
+```
+
+**좌상, 좌, 우**를 확인하는데 편리하기 위해 `[[0]*(M+1) for _ in range(N+1)]`로 한 줄의 padding을 추가했다. 이에 맞춰 `x`, `y`도 원래 값보다 +1 하여 사용하였다.
\ No newline at end of file
diff --git a/_posts/2024-11-06-dockerCH1.markdown b/_posts/2024-11-06-dockerCH1.markdown
new file mode 100644
index 00000000000..fa5374e902a
--- /dev/null
+++ b/_posts/2024-11-06-dockerCH1.markdown
@@ -0,0 +1,105 @@
+---
+title: "CH1. 도커란 무엇인가? [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-11-06T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 1. 도커란 무엇인가?
+---
+## 1. 도커의 기능
+
+> 도커는 '데이터 또는 프로그램을 격리시키는 기능'을 제공하는 소프트웨어다.
+
+주로 서버에 사용되며, 다양한 프로그램과 데이터를 각각 독립된 환경에 격리하는 기능을 제공한다. 운영체제(비슷한 것) 통째로 격리하는 기능이다.
+
+
+## 2. 컨테이너와 도커 엔진
+
+### 2-1. 컨테이너
+
+> 컴퓨터(서버) 상의 환경을 작게 분할한 공간
+
+이렇게 나누어진 컨테이너에 데이터나 프로그램을 두어 격리한다. 이를 격리하는 기능을 제공하는 소프트웨어가 도커다.
+도커는 도커 소프트웨어 본체인 **도커 엔진**을 설치해 사용한다. 이 **도커 엔진**을 사용하여 컨테이너를 생성하고 구동할 수 있다.
+
+#### 이미지
+
+컨테이너를 만드는 데에는 도커 엔진 외에도 **이미지**가 필요하다
+
+> 이미지는 컨테이너의 빵틀과도 같은 역할을 하는 것
+
+이미지에는 많은 종류가 있다. 아파치 컨테이너를 만들려면 아파치 이미지를 사용하고, MySQL 컨테이너를 만들려면 MySQL 이미지를 사용한다.
+
+용량이 허락하는 한, 하나의 도커에서 여러 개의 컨테이너를 만들 수 있다.
+
+### 2-2. 도커의 작동
+> 도커는 리눅스 상에서 동작한다.
+
+Windows나 MacOS에서도 동작하지만 결국 내부적으로 리눅스가 개입한다. 또한, 컨테이너에서 동작시킨 프로그램도 리눅스용 프로그램이다.
+
+
+## 3. 도커의 필요성
+
+### 3-1. 격리의 필요성
+
+> 프로그램은 단독으로 동작하지 않는다.
+
+대부분의 프로그램은 어떤 실행 환경이나 라이브러리, 다른 프로그램을 이용해 동작한다.
+예를 들어 PHP로 작성된 프로그램을 실행하는 데는 PHP 실행 환경이 필요할 것이고, python으로 작성된 프로그램은 다른 라이브러리를 사용하는 경우가 많다.
+
+소프트웨어도 마찬가지로 여러 개의 프로그램으로 구성된 경우가 많다. 예를 들어 WordPress는 MySQL 데이터베이스를 따로 갖추지 않으면 사용할 수 없다.
+다른 경우로는 프로그램들이 특정한 directory를 공유하거나 같은 경로에 성정을 저장하기도 한다.
+
+이 때문에 하나의 프로그램 업데이트가 다른 프로그램들에 영향을 미치게 되는 경우가 발생한다.
+또는, 서버를 구축할 때 이런 문제가 발생할 수 있다. 서버에서는 여러 프로그램이 함께 동작하게 된다. 이 때 설계 단계에서 나타나지 않은 문제가 발생하기도 한다. 이 경우 대부분 프로그램 간의 공유 때문에 발생한다.
+
+### 3-2. 프로그램의 격리
+
+도커 컨테이너는 완전히 독립된 환경이므로 여러 컨테이너에서 같은 프로그램을 실행할 수 있다. 일반적으로 한 컴퓨터에 한 벌의 소프트웨어만을 설치할 수 있다. 하지만 격리를 통해 다양한(혹은 같은) 버전의 소프트웨어를 설치할 수 있다.
+
+---
+
+# SECTION 2. 서버와 도커
+---
+## 1. 서버
+
+### 1-1. 두 가지 의미의 서버
+
+기능적 의미의 서버는 **어떤 기능을 제공하는 의미**이다. 즉, 우베 기능을 제공하는 서버는 '웹 서버'이고, 메일 기능을 제공하는 서버는 '메일 서버'가 된다.
+
+물리적 컴퓨터로의 서버는 데스크톱 컴퓨터와 마찬가지로 어딘가에 **물리적으로 존재하는 컴퓨터**이다.
+
+개인용 컴퓨터는 개인이 사용하지만 서버는 여러 사람잉 원격으로 접근해 사용한다.
+
+### 1-2. 서버의 기능
+
+> 서버의 기능은 소프트웨어가 제공한다.
+
+아파치 같은 웹 서버 소프트웨어를 설치하면 웹 서버 기능을 갖추며, Sendmail 같은 메일 서버 소프트웨어를 설치하면 메인 서버가 된다.
+그리고 기능이 소프트웨어에서 나온다는 말은 "**여러가지 소프트웨어를 한 컴퓨터에 설치할 수 있다**"는 말이다. 그러므로 여러 기능적 의미의 서버가 하나의 물리적 컴퓨터에 함께 존재할 수 있다.
+
+### 1-3. 자유로이 옮길 수 있는 컨테이너
+
+> 도커를 이용하면 물리적 환경의 차이, 서버 구성의 차이를 무시할 수 있다.
+
+컨테이너는 자유롭게 옮길 수 있다. 실제 컨테이너 자체를 옮긴다기 보다는 컨테이너의 정보를 내보내기한 다음, 다른 도커 엔진에서 복원하는 형태이다.
+
+이런 특성을 통해 똑같은 상태로 튜닝한 컨테이너를 팀원 전원에게 배포해 모두가 돌일한 개발환경을 사용할 수 있다.
+
+## 도커 VS. 가상화
+
+### 가상화 기술
+
+메인보드, CPU, RAM 등의 물리적인 부품을 소프트웨어로 구현하여 대체하는 것.
+실질적으로 물리 서버와 동등한 것이므로 운영체제도 아무 것이나 설치할 수 있고, 그 위에 어떤 소프트웨어를 구동해도 무방하다.
+
+### 도커
+
+컨테이너에서 리눅스가 동작하는 것처럼 보이지만 실제 리눅스가 동작하는 것은 아니다. 운영체제의 기능 중 일부를 호스트 역할을 하는 물리 서버에 맡겨 부담을 덜어 둔 형태이다.
+즉, 컨테이너는 운영체제의 일부 기능을 호스트 컴퓨터에 의존하기 때문에 물리 서버에도 리눅스 기능이 필요하며, 컨테이너의 내용도 리눅스 운영체제가 될 수 밖에 없다.
+
+![vm vs docker](/posting_imgs/vm_docker.png)
\ No newline at end of file
diff --git a/_posts/2024-11-07-dockerCH2.markdown b/_posts/2024-11-07-dockerCH2.markdown
new file mode 100644
index 00000000000..295e3bdfcbd
--- /dev/null
+++ b/_posts/2024-11-07-dockerCH2.markdown
@@ -0,0 +1,164 @@
+---
+title: "CH2. 도커의 동작 원리 [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-11-07T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 1. 도커의 동작 원리
+---
+## 2. 도커의 구조
+
+![docker structure](/posting_imgs/docker_structure.png){: width="80%"}
+
+위 그림은 도커의 간단한 구조를 나타낸 것이다. 물리 서버가 있고, 여기서 동작하는 리눅스 운영체제가 있다.
+
+일반적인 서버라면 이 상황에서 운영체제 위에 프로그램이나 데이터가 직접 올라가겠지만 도커를 사용하는 경우에는 **OS 위에 도커 엔진이 동작하고 그 위에서 컨테이너가 동작**한다.
+
+### 2-1. OS는 뭘 하는가?
+
+> 소프트웨어나 프로그램의 명령을 하드웨어에 전달하는 역할을 한다.
+
+하드웨어는 자신의 판단으로 여러 의미 중 적절한 것을 고르거나 적당히 일을 할 수 없고, 지시받은 대로만 수행할 수 있으므로 동작 하나하나를 지정해 주지 않으면 안 된다.
+
+OS는 이런 일들을 하드웨어가 알아들을 수 있게 번역하여 전달하게 된다.
+
+### 2-2. 도커의 리눅스 OS 비슷한 것
+
+본래 OS는 '커널'이라는 부분과 '그 이외의 주변 부분'으로 구성된다. 주변 부분이 프로그램의 연락 내용을 커널에 전달하고 커널이 하드웨어를 다룬다.
+
+여기서 도커의 컨테이너는 운영체제의 주변 부분을 가지고 있다. 이를 통해 프로그램의 명령을 전달받고, 이를 밑바탕이 되는 커널에 전달하는 구조로 되어 있다.
+
+이 덕분에 OS 전체를 컨테이너에 넣지 않을 수 있어, 도커는 가장 큰 특징인 '가벼움'을 얻을 수 있다.
+
+### 2-3. 도커는 기본적으로 Linux 용이다.
+
+> 도커는 리눅스 운영체제가 동작하는 것을 전제로 하는 구조로 되어 있기 때문에 리눅스 운영체제에서만 동작할 수 있다.
+
+그러므로 컨테이너 안에 들어 있는 주변 부분도 이에 맞춰 리눅스 운영체제의 주변 부분이어야 한다.
+
+도커에 대한 이야기는 보통 서버 환경을 전제로 한 것이 많은데, 리눅스 운영체제가 서버에서 사용되는 경우가 많고, 리눅스용 SW도 서버용 SW가 많기 때문이다.
+
+#### 윈도우와 macOS에서 도커 구동하기
+
+VirtualBox나 VMware와 같은 가상 환경 위에 리눅스 운영체제를 설치하고 그 위에서 도커를 실행하거나$^{1)}$, '윈도우 / macOS 용 도커 데스크톱'처럼 도커를 실행하는 데 필요한 리눅스 운영체제를 포함하는 패키지를 설치$^{2)}$해 사용한다.
+
+즉, 도커를 사용하려면 **어떤 형태로든 리눅스 운영체제를 갖춰야 한다**.
+
+---
+
+# SECTION 2. 도커 허브와 이미지, 그리고 컨테이너
+---
+## 1. 이미지
+
+> 이미지는 컨테이너를 만드는 데 사용하는 금형과 같다.
+
+이미지는 금형과 같은 역할을 하는 것으로, 하나만 있으면 똑같은 것을 여러 개 만들 수 있다.
+덕분에 동일한 컨테이너를 여러 개 배치라기 편리하다.
+
+이미지로만 컨테이너를 만들 수 있는 것이 아니라 컨테이너로도 이미지를 만들 수 있다.
+업데이트를 한 컨테이너의 이미지를 만들어 해당 형태의 컨테이너를 바로 만들 수 있게 된다.
+
+이런 특성 덕분에 동일한 컨테이너를 여러 개 만들지 않아도 컨테이너를 이동시킬 수 있다.
+컨테이너는 도커 엔진만 설치되어 있으면 구동이 가능하므로, 다른 서버나 컴퓨터에 도커 엔진을 설치하고 새로운 도커 엔진에 이미지를 이용해 똑핱은 컨테이너를 생성할 수 있다.
+
+### 1-1. 도커 허브
+
+도커 허브는 공개된 컨테이너 이미지가 모여 있는 곳이다.
+도커 허브에는 운영체제 주변부만 들어 있는 이미지부터 여러 소프트웨어가 포함된 이미지까지 다양한 것들이 존재한다.
+
+또한, 리눅스에는 다양한 배포판이 있는데 이들의 이미지도 모두 제공된다.
+
+#### 안전한 컨테이너 이미지를 고르는 방법
+
+1. 공식 이미지를 사용한다
+
+도커에서 직접 배포하거나 해당 소프트웨어를 개발 및 관리하는 기업이나 조직에서 제공하는 것이 있다.
+이런 공식 이미지를 사용하면 이미지 선택도 쉽고 보안도 챙길 수 있다.
+
+다만 컨테이너가 특정 운영체제 및 버전으로 한정되는 경우가 있어, 꼭 특정 운영체제 및 버전을 사용해야 하는 경우 주의해야 한다.
+
+2. 커스텀 이미지
+
+필요한 최소의 요소가 담긴 이미지에 필요한 소프트웨어를 추가로 설치해 커스텀 이미지를 만든다.
+
+컨테이너는 다양한 조합을 고려해야 한다. 도커를 사용할 때의 원칙 중 하나로 "한 컨테이너에 한 프로그램"이라는 것이 있다. 이렇게 관리하는 것이 보안 및 유지 관리 측면에서 유리하기 때문에 많이 쓰이는 정책이다.
+
+## 운영체제 주변부를 한 종류로 통일해야 할까?
+
+컨테이너 간에 완전히 격리되어 있으므로 서로 다른 배포판을 사용할 수 있으며, 이는 도커의 매력 중 하나이다.
+
+하지만 컨테이너에 로그인을 할 필요가 있거나 특정 DBMS를 사용할 때는 운영체제 종류에 따라 문제를 일으킬 수 있으므로 배포판을 정확히 선택해야 한다.
+
+---
+
+# SECTION 3. 도커 컨테이너의 생애주기와 데이터 저장
+---
+> 컨테이너는 '오랫동안 아껴 쓰는 물건'이 아니라 '그때 그때 쓰고 버리는 일회용품'에 가깝다.
+
+## 1. 컨테이너의 생애 주기
+
+컨테이너는 쉽게 만들 수 있기 때문에, 하나를 업데이트하면서 계속 사용하기보다는 업데이트된 소프트웨어가 들어있는 새로운 컨테이너를 사용하는 것이 좋다.
+
+기본적으로 컨테이너는 여러 개를 동시에 가동하는 상황을 전제로 하는데 이를 모두 업데이트하려면 많은 수고가 든다. 이는 컨테이너의 장점이 퇴색되는 것이다.
+
+그러므로 오래된 컨테이너를 버리고 새로운 이미지로부터 새로운 컨테이너를 만들어 갈아타는 방식을 사용한다.
+이처럼 컨테이너를 '만들고', '실행하고', '종료하고', '폐기'한 다음 다시 컨테이너를 '만드는' 일련의 과정을 **컨테이너의 생애 주기**라고 한다.
+
+### 1-1. 데이터 저장
+
+컨테이너를 폐기할 때 데이터를 보존하기 위해 **도커가 설치된 물리적 서버(호스트)의 디스크를 마운트해** 이 디스크에 데이터를 저장한다.
+
+여기서 마운트는 "디스크를 연결해 데이터를 기록할 수 있도록 한 상태"를 의미한다. 이런 방법으로 컨테이너 외부에 데이터를 안전하게 저장한다.
+
+운영체제나 소프트웨어 부분은 컨테이너 형태로 만들어 쓰고 버리는 것을 반복하고, 데이터는 다른 곳에 저장해 계속 사용한다. 이는 설정 파일도 마찬가지로 파일을 수정했다면 삭제되지 않을 곳에 저장한다.
+
+그러나 프로그램을 개발 할 때는 다른 저장소에 저장하지 않는 경우도 있으므로 컨테이너를 폐기하기 전 중요한 데이터가 컨테이너에 포함되어 있는지 확인해야 한다.
+
+---
+
+# SECTION 4. 도커의 장점과 단점
+---
+
+## 1. 도커의 구조와 성질 및 그 장단점
+
+### 1-1. 환경을 격리할 수 있다.
+
+#### 독립된 환경
+
+독립된 환경 덕분에 여러 개의 컨테이너를 띄울 수 있으며, 똑같은 애플리케이션도 여러 개 띄울 수 있다.
+
+#### 이미지를 만들 수 있다.
+
+이미지를 만들고 배포할 수 있으므로, 모든 이미지를 처음부터 만들지 않아도 이미지를 내려받아 편하게 사용할 수 있다.
+
+또한 구축 작업이 간단해져서 교체가 쉽고, 업데이트가 쉽다. 이는 이동성이 좋다는 특성으로도 이어진다. 똑같은 컨테이너를 쉽게 만들 수 있으므로, 환경 이동이나 개발환경을 구축하기도 쉽다.
+
+#### 컨테이너에 커널을 포함할 필요가 없다
+
+컨테이너에는 커널이 없어도 되어 가볍다.
+
+### 1-2. 도커의 장단점
+
+#### 장점
+
+- 한 대의 물리 서버에 여러 대의 서버를 띄울 수 있다.
+- 서버 관리가 용이하다.
+- 서버 고수가 아니어도 다루기 쉽다.
+
+#### 단점
+
+- 리눅스용 소프트웨어만 지원한다.
+- 호스트 서버에 문제가 생기면 모든 컨테이너에 영향이 미친다.
+
+### 1-3. 도커의 주 용도
+
+- 팀원 모두에게 동일한 개발환경 제공
+  - 동일한 환경을 여러 개 만들기
+- 새로운 버전의 테스트
+  - 격리된 환경을 이용
+- 동일한 서버가 여러 대 필요한 경우
+  - 컨테이너 밖과 독립된 성질을 이용
\ No newline at end of file
diff --git a/_posts/2024-11-17-dockerCH4.markdown b/_posts/2024-11-17-dockerCH4.markdown
new file mode 100644
index 00000000000..775f12887a3
--- /dev/null
+++ b/_posts/2024-11-17-dockerCH4.markdown
@@ -0,0 +1,612 @@
+---
+title: "CH4. 컨테이너를 실행해 보자 [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-11-17T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 1. 도커 엔진 시작하기/종료하기
+---
+## 리눅스에서 시작하기
+```bash
+# 도커 엔진 시작
+sudo systemtl start docker
+# 도커 엔진 종료
+sudo systemtl stop docker
+# 자동 실행 설정
+sudo systemtl enable docker
+```
+
+---
+
+# SECTION 2. 컨테이너의 기본적인 사용방법
+> 컨테이너를 다루는 모든 명령은 `docker` 명령어로 시작한다
+```bash
+docker ~
+```
+
+## 명령어와 대상
+
+`docker` 명령어 뒤에 '무엇을', '어떻게', '대상' 순으로 지정하여 명령어를 작성한다.
+
+![](/posting_imgs/docker-command1.png)
+
+'무엇을', 어떻게 부분을 커맨드라고 하고, 상위 커맨드가 '무엇을', 하위 커맨드가 '어떻게'에 해당하는 내용을 지정한다.
+
+상위 커맨드에 들어가는 **대상의 종류**는 12종류이다. 개인적으로는 프로그래밍 언어에서의 type과 같은 것이라고 이해했다.
+
+```bash
+docker image pull penguin
+docker container start penguin
+...
+```
+
+## 옵션과 인자
+
+필요에 따라 '옵션'이나 '인자'를 붙여 사용하는 경우도 있다
+
+![](/posting_imgs/docker-command2.png)
+
+위 명령어는 penguin container를 백그라운드로(`-d`), mode 1로(`--mode=1`) 실행하라는 의미이다.
+
+모든 명령어에 옵션이나 인자가 붙는 것은 아니며, 여러개 붙을 수 있는 명령어라도 자주 쓰이는 것은 한정되어 있으므로 기억해놓는 것이 좋다.
+
+## 기본적인 명령어
+
+### 컨테이너 조작 관련 커맨드(`container`)
+
+| 하위 커맨드 | 내용                                                                                                                      | 생략 가능 여부 |               주요 옵션                |
+| :---------: | :------------------------------------------------------------------------------------------------------------------------ | :------------: | :------------------------------------: |
+|   `start`   | 컨테이너 실행                                                                                                             |       O        |                  `-i`                  |
+|   `stop`    | 컨테이너 정지                                                                                                             |       O        |           거의 사용하지 않음           |
+|  `create`   | 도커 이미지로부터 컨테이너를 생성                                                                                         |       O        |        `--name` `-e` `-p` `-v`         |
+|    `run`    | 도커 이미지를 내려받고 컨테이너를 생성해 실행(`docker image pull` + `docker container create` + `docker container start`) |       O        | `--name` `-e` `-p` `-v` `-d` `-i` `-t` |
+|    `rm`     | 정지 상태의 컨테이너 삭제                                                                                                 |       O        |               `-f` `-v`                |
+|   `exec`    | 실행 중인 컨테이너 속에서 프로그램을 실행                                                                                 |       O        |               `-i` `-t`                |
+|    `ls`     | 컨테이너 목록 출력                                                                                                        |  `docker ps`   |                  `-a`                  |
+|    `cp`     | 도커 컨테이너와 도커 호스트 간에 파일 복사                                                                                |       O        |           거의 사용하지 않음           |
+|  `commit`   | 도커 컨테이너를 이미지로 변환                                                                                             |       O        |           거의 사용하지 않음           |
+
+
+### 이미지 조작 관련 커맨드(`image`)
+
+| 하위 커맨드 | 내용                                            | 생략 가능 여부 |     주요 옵션      |
+| :---------: | :---------------------------------------------- | :------------: | :----------------: |
+|   `pull`    | 도커 허브 등의 repository에서 이미지를 내려받음 |       O        | 거의 사용하지 않음 |
+|    `rm`     | 도커 이미지 삭제                                |  `docker rmi`  | 거의 사용하지 않음 |
+|    `ls`     | 내려받은 이미지 목록                            |       X        | 거의 사용하지 않음 |
+|   `build`   | 도커 이미지를 생성                              |       O        |        `-t`        |
+
+### 볼륨 조작 관련 커맨드(`volume`)
+
+| 하위 커맨드 | 내용                           | 생략 가능 여부 |     주요 옵션      |
+| :---------: | :----------------------------- | :------------: | :----------------: |
+|  `create`   | 볼륨 생성                      |       X        |      `--name`      |
+|  `inspect`  | 볼륨의 상세 정보 출력          |       X        | 거의 사용하지 않음 |
+|    `ls`     | 볼륨 목록                      |       X        |        `-a`        |
+|   `prune`   | 마운트되지 않은 볼륨 모두 삭제 |       X        | 거의 사용하지 않음 |
+|    `rm`     | 지정한 볼륨 삭제               |       X        | 거의 사용하지 않음 |
+
+### 네트워크 조작 관련 커맨드(`network`)
+
+도커 네트워크란 도커 요소 간의 톤신에 사용하는 가장 네트워크이다.
+
+| 하위 커맨드  | 내용                                   | 생략 가능 여부 |     주요 옵션      |
+| :----------: | :------------------------------------- | :------------: | :----------------: |
+|  `connect`   | 컨테이너를 도커 네트워크에 연결        |       X        | 거의 사용하지 않음 |
+| `disconnect` | 컨테이너를 도커 네트워크 연결 해제     |       X        | 거의 사용하지 않음 |
+|   `create`   | 도커 네트워크 생성                     |       X        | 거의 사용하지 않음 |
+|  `inspect`   | 도커 네트워크 상세 정보 출력           |       X        | 거의 사용하지 않음 |
+|     `ls`     | 도커 네트워크 목록                     |       X        | 거의 사용하지 않음 |
+|   `prune`    | 컨테이너가 접속하지 않은 네트워크 삭제 |       X        | 거의 사용하지 않음 |
+|     `rm`     | 지정한 네트워크 삭제                   |       X        | 거의 사용하지 않음 |
+
+### 단독으로 쓰이는 커맨드
+
+도커 허브의 검색이나 로그인에 사용되는 커맨드
+
+| 커맨드 | 내용                                 |     주요 옵션      |
+| :---------: | :----------------------------------- | :----------------: |
+|   `login`   | 도커 레지스트리에 로그인             |       -u -p        |
+|  `logout`   | 도커 레지스트리에 로그아웃           | 거의 사용하지 않음 |
+|  `search`   | 도커 레지스트리를 검색               | 거의 사용하지 않음 |
+|  `version`  | 도커 엔진 및 명령행 도구의 버전 출력 | 거의 사용하지 않음 |
+
+
+# SECTION 3. 컨테이너의 생성과 삭제, 실행, 정지
+
+도커 커맨드에는 컨테이너를 생성하는 `docke (container) create`, 실행하는 `docker (container) start`, 이미지를 내려받는 `docker (container) pull` 이 따로 존재하지만 이를 한 번에 수행할 수 있는 `docker (container) run`을 사용하는 것이 일반적이다.
+
+![](/posting_imgs/docker-lifecycle.png)
+
+2장에서 나왔던 생애주기에 따라 컨테이너는 쓰고 버리는 방식으로 사용한다. 동작 중인 컨테이너를 그대로 삭제할 수 없으므로 정지하는 방법과 삭제하는 방법을 함께 알아야 한다.
+
+## `docker (container) run`
+
+컨테이너를 생성해 실행한다. 해당 이미지르 내려받으 상태가 아니라면 먼저 이미지를 내려받는다. '대상'으로는 이미지의 이름을 지정한다.
+
+|             옵션 형식             | 내용                                                                                            |    Full name    |
+| :-------------------------------: | :---------------------------------------------------------------------------------------------- | :-------------: |
+|             `--name`              | 컨테이너 이름 지정                                                                              |        -        |
+| `-p {host_port}:{container_port}` | 포트 번호 지정                                                                                  |   `--publish`   |
+| `-v {host_disk}:{container_dir}`  | 볼륨 마운트                                                                                     |   `--volume`    |
+|      `--net={natwork_name}`       | 컨테이너를 네트워크에 연결                                                                      |     `-env`      |
+|    `-e {env-var_name}={vlaue}`    | 환경 변수를 설정                                                                                |        -        |
+|               `-d`                | 백그라운드로 실행                                                                               |   `--detach`    |
+|               `-i`                | 컨테이너에서 터미널(키보드) 연결 (표준 입력으로 컨테이너 생성)                                  | `--interactive` |
+|               `-t`                | 특수 키를 사용 가능하도록 함 (터미널 드라이버를 추가하여 터미널을 이용하여 연결할 수 있도록 함) |     `--tty`     |
+|              `-help`              | 사용 방법 안내 메세지                                                                           |        -        |
+
+## `docker (container) stop`
+
+```bash
+docker stop {container_name}
+```
+
+## `docker (container) rm`
+
+```bash
+docker rm {container_name}
+```
+
+### 한 번만 실행되는 컨테이너와 데몬 형태로 동작하는 컨테이너
+
+`-d`를 붙이지 않고 컨테이너를 싱행하면 실행된 컨테이너가 프로그램의 실행을 마칠 때까지 터미널의 제어를 차지하므로 다음 명령을 입력할 수 없다.
+`-it`를 붙이지 않으면 컨테이너 안의 파일 시스템이 접근할 수 없다.
+
+한 번만 실행되는 컨테이너는 실행하자마자 종료되므로 컨테이너가 터미널의 제어를 차지해도 일시적이므로 문제가 되지 않는다.
+하지만 데몬처럼 지속적으로 실행되는 경우 저절로 종료되지 않으므로 한 번 터미널 제어를 넘지면 이를 되찾아오기 번거롭다.
+
+또한 바로 종료되는 컨테이너의 경우 컨테이너 속 파일 시스템에 접근할 필욕사 없으므로 `-it`가 필요없는 옵션이 된다.
+
+## `docker ps (docker container ls)`
+
+```bash
+# 실행 중인 컨테이너 확인
+docker ps
+
+# 존재하는 컨테이너 확인 (정지된 컨테이너 포함)
+docker ps -a
+```
+
+> `ps`는 **pocess status**를 의미한다
+
+### 컨테이너 목록 정보
+
+목록을 출력하면 다음과 같은 정보들이 출력된다.
+```
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
+```
+
+자세한 내용은 다음과 같다.
+
+|      항목      | 내용                                                                                                        |
+| :------------: | :---------------------------------------------------------------------------------------------------------- |
+| `CONTAINER ID` | 컨테이너 식별자, 무작위 문자열이 할당된다. (SHA256 해시 알고리즘)                                           |
+|    `IMAGE`     | 컨테이너를 만들 때 사용한 이미지의 이름                                                                     |
+|   `COMMAND`    | 컨테이너 실행 시에 실행되도록 설정한 프로그램 이름                                                          |
+|   `CREATED`    | 컨테이너 생성 후 경과된 시간                                                                                |
+|    `STATUS`    | 컨테이너의 현재 상태. 실행 중이면 'Up', 종료 상태이면 'Exited'                                              |
+|    `PORTS`     | 컨테이너에 할당된 포트 번호 'host_port -> container_port'형식으로 출력. 포트 번호가 동일할 경우 하나만 출력 |
+|    `NAMES`     | 컨테이너 이름                                                                                               |
+
+
+#### SHA256
+
+docker에서의 입력값
+
+- 이미지:
+  - 이미지 레이어 정보
+  - 파일 및 디렉터리의 해시 값
+  - Dockerfile 명령과 빌드 옵션
+- 컨테이너:
+  - 랜덤 데이터(랜덤 시드, 시간, 호스트 정보 등)
+  - 생성 시 옵션과 환경 변수
+
+
+SHA-256은 **SHA-2(Secure Hash Algorithm 2)** 계열의 암호학적 해시 함수로, 입력 데이터를 고정된 256비트(32바이트) 해시 값으로 변환합니다. 데이터 무결성 검증 및 고유 식별자 생성 등에 널리 사용됩니다.
+
+---
+
+##### **특징**
+1. **입력 크기 제한 없음**:
+   - 어떤 크기의 데이터도 입력으로 처리 가능.
+
+2. **출력 크기 고정**:
+   - 항상 **256비트(64자리 16진수)** 길이의 해시 값을 생성.
+
+3. **결정론적**:
+   - 동일한 입력은 항상 동일한 해시 값을 생성.
+
+4. **충돌 저항성**:
+   - 서로 다른 입력이 동일한 해시 값을 가질 확률이 극히 낮음.
+
+5. **비가역성**:
+   - 해시 값으로 원본 데이터를 복원 불가.
+
+6. **빠른 계산**:
+   - 입력 데이터 크기와 관계없이 빠르게 계산 가능.
+
+---
+
+##### **주요 사용 사례**
+1. **데이터 무결성 검증**:
+   - 파일이 전송 중 변경되지 않았는지 확인.
+   - 예: 소프트웨어 배포 시 파일의 SHA-256 해시 제공.
+
+2. **암호학**:
+   - 디지털 서명, 인증서, 전자 서명 등에 활용.
+
+3. **비밀번호 저장**:
+   - 비밀번호를 해시 값으로 변환하여 안전하게 저장.
+   - 
+4. **블록체인**:
+   - Bitcoin 등 블록체인 기술에서 트랜잭션 및 블록 해시에 사용.
+
+5. **고유 식별자 생성**:
+   - 파일, 데이터, 이미지 등에서 고유 ID 생성.
+
+---
+
+##### **SHA-256의 동작 원리**
+1. **패딩(Padding)**:
+   - 입력 데이터를 512비트의 배수로 채움. 마지막 64비트는 원래 데이터 길이 정보 포함.
+
+2. **초기 해시 값 설정**:
+   - 256비트 크기의 초기 해시 값(8개의 32비트 단어)을 정의.
+
+3. **메시지 분할**:
+   - 입력 데이터를 512비트 블록으로 분할.
+
+4. **압축 함수(Compression Function)**:
+   - 각 블록에 대해 비트 연산을 반복하여 해시 값 갱신.
+
+5. **최종 해시 값 출력**:
+   - 모든 블록 처리 후, 256비트 최종 해시 값 반환.
+
+---
+
+##### **Python을 사용한 SHA-256 해시 생성 예제**
+```python
+import hashlib
+
+data = "hello"
+sha256_hash = hashlib.sha256(data.encode()).hexdigest()
+print("SHA-256 Hash:", sha256_hash)
+
+# SHA-256 Hash: 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
+```
+---
+
+
+## [실습] 컨테이너 생성, 실행 상태확인, 종료, 삭제
+
+```bash
+PS C:\Users\Kwon> docker ps
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
+
+# docker image pull + docker container create + docker container start
+PS C:\Users\Kwon> docker run --name apa000ex1 -d httpd 
+latest: Pulling from library/httpd
+334a67c7f78b: Download complete
+3ed0d9182dde: Download complete
+d675ed392a91: Download complete
+0062038102c9: Download complete
+4f4fb700ef54: Download complete
+2d429b9e73a6: Download complete
+Digest: sha256:6bdbdf5ac16ac3d6ef543a693fd5dfafae2428b4b0cdc52a480166603a069136
+Status: Downloaded newer image for httpd:latest
+174a5c39573f4df13fad5620c4899bcde5828ff7b983e4456de688227e0ccecd
+
+# 실행된 container 확인
+PS C:\Users\Kwon> docker ps
+CONTAINER ID   IMAGE     COMMAND              CREATED          STATUS          PORTS     NAMES
+174a5c39573f   httpd     "httpd-foreground"   12 seconds ago   Up 11 seconds   80/tcp    apa000ex1
+
+# container 정지
+PS C:\Users\Kwon> docker stop apa000ex1
+apa000ex1
+
+CONTAINER ID   IMAGE     COMMAND              CREATED         STATUS                      PORTS     NAMES
+# 정지되었으므로 ps -a로 확인할 수 있음 (STATUS: Exited)
+PS C:\Users\Kwon> docker ps
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
+
+PS C:\Users\Kwon> docker ps -a
+CONTAINER ID   IMAGE     COMMAND              CREATED         STATUS                      PORTS     NAMES
+174a5c39573f   httpd     "httpd-foreground"   3 minutes ago   Exited (0) 12 seconds ago             apa000ex1
+
+# container 삭제
+PS C:\Users\Kwon> docker rm apa000ex1
+apa000ex1
+
+PS C:\Users\Kwon> docker ps -a       
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
+```
+
+# SECTION 4. 컨테이너의 통신
+
+## 아파치
+
+> 아파치는 웹 서버 기능을 제공하는 소프트웨어이다.
+
+웹 브라우저를 통해 들어온 요청에 따라 아파치 서버가 웹 사이트의 내용을 반환해준다.
+
+## 컨테이너와의 통신
+
+웹 브라우저를 통해 컨테이너에 접근하려면 외부와 접속하기 위한 설정이 필요하다. 이를 위해 포트를 설정한다.
+
+> **port**는 통신 내용이 드나드는 통로이다.
+
+docker에서는 `-p` 옵션으로 설정할 수 있다.
+
+컨테이너를 사용하면 여러 개의 웹 서버를 함께 실행할 수도 있다. 이러한 경우 컨테이너와 연결하는 호스트의 포트 번호를 겹치지 않게 성정해야 한다.
+
+### Reverse Proxy
+
+#### Forard Proxy
+
+client가 직접 server에 요청하는 것이 아니라 proxy server(중계 서버)를 거쳐 요청하는 것.
+이렇게 되면 사실상 proxy server가 요청하는 것으로 되기 때문에 client가 누군지 server는 알 수 없다.
+
+#### Reverse Proxy
+
+reverse proxy는 server가 반환해주는 data를 proxy server가 대신 해주는 것이다. 그러므로 client는 server의 정보를 알 수 없다.
+보안상 이점이 있으며, 서버 부담을 분산할 수 있다.
+
+![](/posting_imgs/proxy.png)
+
+reverse proxy를 활용하면 여러 대의 서버에 proxy가 요청을 전달 하게 할 수 있다. 그러므로 같은 포트로 요청이 들어왔을 때 proxy가 서버를 구분하는 방식으로 알맞은 컨테이너에 요청을 보낼 수 있다.
+
+## [실습]
+
+```bash
+# host: 8080, container: 80으로 아파치 서버 container를 실행
+PS C:\Users\Kwon> docker run --name apa000ex2 -d -p 8080:80 httpd
+4ea55871346bea8332fdd1aee1c23620aff366895fbc573144b5cf4bd246d710
+PS C:\Users\Kwon> docker ps
+CONTAINER ID   IMAGE     COMMAND              CREATED          STATUS          PORTS                  NAMES
+4ea55871346b   httpd     "httpd-foreground"   20 seconds ago   Up 19 seconds   0.0.0.0:8080->80/tcp   apa000ex2
+
+# 정지 및 삭제
+PS C:\Users\Kwon> docker stop apa000ex2
+apa000ex2
+PS C:\Users\Kwon> docker rm apa000ex2  
+apa000ex2
+PS C:\Users\Kwon> docker ps -a
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
+PS C:\Users\Kwon>
+```
+
+![실습 실행 화면](/posting_imgs/net_test.png)
+
+위와 같은 실행 화면을 얻을 수 있다.
+
+---
+
+# SECTION 5. 컨테이너 생성에 익숙해지기
+
+## 리눅스 운영체제가 담긴 컨테이너
+
+리눅스 운영체제 컨데이너는 컨테이너 속 파일 시스템을 다루는 것을 전제로 하므로 인자로 '셀 명령어'를 지정한다.
+
+즉 `-d` 없이 `-it` 옵션만 사용한다. 인자로는 `/bin/bash` 등 셀 명령어를 지정한다.
+
+| 이미지 이름 | 컨테이너의 내용 |
+| :---------: | :-------------: |
+|   ubuntu    |     우분투      |
+|   centos    |     CentOS      |
+|   edbian    |     데비안      |
+|   fedora    |     페도라      |
+|   busybox   |     BizyBox     |
+|   alpine    |  알파인 리눅스  |
+
+## 웹 서버/데이터베이스 서버용 컨테이너
+
+웹 서버는 통신이 전제가 되므로 옵션을 통해 포트 번호를 지정해야 한다.
+
+데이터베이스 관리 소프트웨어는 기본적으로 **루트 패스워드**를 반드시 지정해야 한다.
+
+| 이미지 이름 | 컨테이너의 내용 | 컨테이너 실행에 주로 사용되는 옵션 및 인자|
+| :---------: | :-------------: |:---:|
+|   httpd    |     우분투      |`-d` `-p`|
+|   nginx    |     CentOS      |`-d` `-p`|
+|   mysql    |     데비안      |`-d` `-e MYSQL_ROOT_PASSWORD`|
+|   postgres    |     Postgre      |`-d` `-e POSTGRES_ROOT_PASSWORD`|
+|   mariadb   |     MariaDB     |`-d` `-e MYSQL_ROOT_PASSWORD`|
+
+## 프로그램 실행을 위한 런타임과 그 외 소프트웨어
+
+프로그램을 실행하려면 해당 언어의 실행 환경인 **런타임**이 필요하다. 이 또한 컨테이너 형태로 제공된다.
+
+| 이미지 이름 | 컨테이너의 내용 | 컨테이너 실행에 주로 사용되는 옵션 및 인자|
+| :---------: | :-------------: |:---:|
+|   openjdk    |     java 런타임      |`-d`를 사용하지 않고 인자로 java 명령 등을 지정해 도구 형태로 사용한다.|
+|   python    |     python 런타임      |`-d`를 사용하지 않고 인자로 python 명령 등을 지정해 도구 형태로 사용한다.|
+|   php    |     PHP 런타임      |웹 서버가 포함된 것과 실행 명령만 포함된 것으로 나위어 제공된다.|
+|   ruby    |     ruby 런타임      |웹 서버가 포함된 것과 실행 명령만 포함된 것으로 나위어 제공된다.|
+|   perl   |     perl 런타임     |`-d`를 사용하지 않고 인자로 perl 명령 등을 지정해 도구 형태로 사용한다|
+|   gcc    |     C/C++ 컴파일러      |`-d`를 사용하지 않고 인자로 gcc 명령 등을 지정해 도구 형태로 사용한다|
+|   node    |     Node.js      |`-d`를 사용하지 않고 인자로 app 명령 등을 지정해 도구 형태로 사용한다|
+|   registry    |     도커 레지스트리      |`-d`옵션을 사용해 백그라운드로 실행한다. `-p` 옵션으로 포트 번호를 지정한다.|
+|   wordpress    |     WordPress      |`-d`옵션을 사용해 백그라운드로 실행한다. `-p` 옵션으로 포트 번호를 지정한다. MySQL 또는 MariaDB가 필요하다. 접속에 필요한 패스워드는 `-e` 옵션으로 지정한다.|
+|   nextcloud   |     NextCloud     |`-d`옵션을 사용해 백그라운드로 실행한다. `-p` 옵션으로 포트 번호를 지정한다.|
+|   redmine   |     Redmine     |`-d`옵션을 사용해 백그라운드로 실행한다. `-p` 옵션으로 포트 번호를 지정한다. PostgreSQL 또는 MySQL이 필요하다|
+
+## [실습] 아파치 컨테이너를 여러 개 실행하기
+
+```bash
+# 여러 개의 아파치 container 실행
+PS C:\Users\Kwon> docker run --name apa000ex3 -d -p 8081:80 httpd
+e21699803316c50412fefe15c8083f002b13f6a77a3fe44425f64df804622b0e
+PS C:\Users\Kwon> docker run --name apa000ex4 -d -p 8082:80 httpd
+fcfaac356cc40277c0855211b0394593db58bbae4c5e70bfb4cf60f10a47fdcb
+PS C:\Users\Kwon> docker run --name apa000ex5 -d -p 8083:80 httpd
+d656af9f2f9bc5c7326efe9c765888586c3564022b13ab14cd8348c8187c5460
+
+PS C:\Users\Kwon> docker ps
+CONTAINER ID   IMAGE     COMMAND              CREATED          STATUS          PORTS                  NAMES
+d656af9f2f9b   httpd     "httpd-foreground"   10 seconds ago   Up 10 seconds   0.0.0.0:8083->80/tcp   apa000ex5
+fcfaac356cc4   httpd     "httpd-foreground"   16 seconds ago   Up 16 seconds   0.0.0.0:8082->80/tcp   apa000ex4
+e21699803316   httpd     "httpd-foreground"   22 seconds ago   Up 22 seconds   0.0.0.0:8081->80/tcp   apa000ex3
+
+# container 중지
+PS C:\Users\Kwon> docker stop apa000ex3
+apa000ex3
+PS C:\Users\Kwon> docker stop apa000ex4
+apa000ex4
+PS C:\Users\Kwon> docker stop apa000ex5
+apa000ex5
+
+PS C:\Users\Kwon> docker ps -a
+CONTAINER ID   IMAGE     COMMAND              CREATED              STATUS                      PORTS     NAMES
+d656af9f2f9b   httpd     "httpd-foreground"   56 seconds ago       Exited (0) 10 seconds ago             apa000ex5       
+fcfaac356cc4   httpd     "httpd-foreground"   About a minute ago   Exited (0) 13 seconds ago             apa000ex4       
+e21699803316   httpd     "httpd-foreground"   About a minute ago   Exited (0) 17 seconds ago             apa000ex3       
+
+# cooontainer 삭제
+PS C:\Users\Kwon> docker rm apa000ex3
+apa000ex3
+PS C:\Users\Kwon> docker rm apa000ex4
+apa000ex4
+PS C:\Users\Kwon> docker rm apa000ex5
+apa000ex5
+
+PS C:\Users\Kwon> docker ps -a
+CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
+```
+
+## [실습] Nginx 컨테이너 실행
+
+```bash
+# Nginx container 실행
+PS C:\Users\Kwon> docker run --name nginx000ex6 -d -p 8084:80 nginx
+Unable to find image 'nginx:latest' locally
+latest: Pulling from library/nginx
+171eebbdf235: Download complete
+9ad567d3b8a2: Download complete
+9b1039c85176: Download complete
+773c63cd62e4: Download complete
+4b0adc47c460: Download complete
+1d2712910bdf: Download complete
+Digest: sha256:bc5eac5eafc581aeda3008b4b1f07ebba230de2f27d47767129a6a905c84f470
+Status: Downloaded newer image for nginx:latest
+eb1e2ba350487505a13e5eda7c72690ca7e999d97d811635d5045c0495e6223f
+
+PS C:\Users\Kwon> docker ps
+CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS         PORTS                  NAMES
+eb1e2ba35048   nginx     "/docker-entrypoint.…"   11 seconds ago   Up 9 seconds   0.0.0.0:8084->80/tcp   nginx000ex6     
+
+# container 중지/삭제
+PS C:\Users\Kwon> docker stop nginx000ex6
+nginx000ex6
+
+PS C:\Users\Kwon> docker ps -a
+CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS                     PORTS     NAMES
+eb1e2ba35048   nginx     "/docker-entrypoint.…"   33 seconds ago   Exited (0) 5 seconds ago             nginx000ex6      
+
+PS C:\Users\Kwon> docker rm nginx000ex6
+nginx000ex6
+```
+
+## [실습] MySQL 컨테이너 실행
+
+```bash
+# MySQL container 실행
+PS C:\Users\Kwon> docker run --name mysql000ex7 -dit -e MYSQL_ROOT_PASSWORD=1234 mysql
+Unable to find image 'mysql:latest' locally
+latest: Pulling from library/mysql
+7030c241d9b8: Pulling fs layer
+f1a9f94fc2db: Download complete
+c0fb96d14e5b: Download complete
+f98254a2b688: Download complete
+5f31e56c9bea: Download complete
+d57074c62694: Download complete
+6ad83e89f981: Download complete
+a42d733ea779: Download complete
+6fd1af2601dd: Download complete
+0233a63dc5cd: Download complete
+Digest: sha256:2be51594eba5983f47e67ff5cb87d666a223e309c6c64450f30b5c59a788ea40
+Status: Downloaded newer image for mysql:latest
+58f387c6520598518264e9f0a70ac6e6d9830bf381157aa96063f9eccfc867e6
+
+PS C:\Users\Kwon> docker ps 
+CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                 NAMES
+58f387c65205   mysql     "docker-entrypoint.s…"   20 minutes ago   Up 20 minutes   3306/tcp, 33060/tcp   mysql000ex7
+
+# container 중지/삭제
+PS C:\Users\Kwon> docker stop mysql000ex7
+mysql000ex7
+PS C:\Users\Kwon> docker rm mysql000ex7
+mysql000ex7
+```
+
+# SECTION 6. 이미지 삭제
+
+container를 여러 번 만들다 보면 image는 그대로 남아있는 문제가 발생한다.
+해당 이미지로 실행한 container가 남아 있으면 image를 삭제할 수 없으므로 사전에 container를 중지 및 삭제한다.
+
+## `docker image rm`
+
+여러 개를 한 번에 삭제할 수도 있다.
+
+```bash
+docker image rm image1 image2 image3
+```
+
+## `docker image ls`
+
+image를 삭제하려면 imgae 이름 또는 id를 알아야 한다.
+
+coantainer 목록을 불러오는 `docker ps`와 같이 `docker container ls`로 image 목록을 불러올 수 있다.
+축약형은 `docker ls`이다.
+
+```sh
+PS C:\Users\Kwon> docker image ls
+REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
+mysql        latest    2be51594eba5   4 weeks ago    825MB
+nginx        latest    bc5eac5eafc5   6 weeks ago    279MB
+httpd        latest    6bdbdf5ac16a   4 months ago   221MB
+```
+
+### image version
+
+`image_name:version`으로 이미지의 버전을 지정할 수 있다.
+
+```sh
+# 아파치 2.2 버전을 지정해 실행
+docker run --name apa000ex2 -d -p 8080:80 httpd:2.2
+```
+
+## [실습] 이미지 삭제
+
+```sh
+PS C:\Users\Kwon> docker image ls
+REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
+mysql        latest    2be51594eba5   4 weeks ago    825MB
+nginx        latest    bc5eac5eafc5   6 weeks ago    279MB
+httpd        latest    6bdbdf5ac16a   4 months ago   221MB
+
+# 축약형
+PS C:\Users\Kwon> docker rmi httpd
+Untagged: httpd:latest
+Deleted: sha256:6bdbdf5ac16ac3d6ef543a693fd5dfafae2428b4b0cdc52a480166603a069136
+
+PS C:\Users\Kwon> docker image ls 
+REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
+mysql        latest    2be51594eba5   4 weeks ago   825MB
+nginx        latest    bc5eac5eafc5   6 weeks ago   279MB
+
+# image rm으로 삭제
+PS C:\Users\Kwon> docker image rm nginx mysql
+Untagged: nginx:latest
+Deleted: sha256:bc5eac5eafc581aeda3008b4b1f07ebba230de2f27d47767129a6a905c84f470
+Untagged: mysql:latest
+Deleted: sha256:2be51594eba5983f47e67ff5cb87d666a223e309c6c64450f30b5c59a788ea40
+
+PS C:\Users\Kwon> docker image ls
+REPOSITORY   TAG       IMAGE ID   CREATED   SIZE
+```
\ No newline at end of file
diff --git a/_posts/2024-12-09-dockerCH5.markdown b/_posts/2024-12-09-dockerCH5.markdown
new file mode 100644
index 00000000000..899e6ec8c02
--- /dev/null
+++ b/_posts/2024-12-09-dockerCH5.markdown
@@ -0,0 +1,158 @@
+---
+title: "CH5. 여러 개의 컨테이너를 연동해 실행해보자 [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-12-09T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 1. 워드프레스 구축
+
+## 워드프레스 구축
+
+워드프레스는 웹 사이트를 만들기 위한 소프트웨어로, 아파치나 데이터베이스, PHP 런타임 등을 필요로 하기 때문에 구축을 위한 연습 소재로 좋다.
+
+워드프레스는 워드프레스 컨테이너와 MySQL 컨테이너로 구성된다.
+워드프레스는 블로그 생성 도구와 같은 것이므로, 프로그램이 MySQL에 저장된 데이터를 읽고 쓸 수 있어야 한다.
+때문에 두 컨테이너가 연결돼 있어야 한다.
+
+두 컨테이너를 연결하기 위해서는 가상 네트워크를 만들어 두 개의 컨테이너를 소속시켜 연결한다.
+네트워크에 대한 기본 명령어는 다음과 같다.
+```sh
+# 생성
+docker network create <network_name>
+# 삭제
+docker network rm
+# 조회
+docker network ls
+# 접속
+docker network connect
+# 접속 끊기
+docker network disconnect
+# 상세 정보
+docker network isnpect
+# 아무도 접속하지 않은 네트워크 삭제
+docker network prune
+```
+
+### MySQL 실행 시 필요한 옵션과 인자
+
+```sh
+docker run --name <container_name> -dit --net=<network_name> -e MYSQL_ROOT_PASSWORD=<root_password> MYSQL_DATABASE=<database_name> -e MYSQL_USER=<user_name> -e MYSQL_PASSWORD=<password> mysql --charactoer-set-server=<문자인코딩> --collation-server=<정렬순서> --default-authentication-plugin=<인증방식>
+```
+
+뭔가 엄청 많아 보이지만 모두 거의 환경변수 설정이다.
+#### 옵션
+
+| 항목                     | 옵션                     |
+| :----------------------- | :----------------------- |
+| 네트워크 이름            | `--net`                  |
+| 컨테이너 이름            | `--name`                 |
+| MySQL 루트 패스워드      | `-e MYSQL_ROOT_PASSWORD` |
+| MySQL 데이터 베이스 이름 | `-e MYSQL_DATABASE`      |
+| MySQL 사용자 이름        | `-e MYSQL_USER`          |
+| MySQL 패스워드           | `-e MYSQL_PASSWORD`      |
+
+#### 인자
+
+|    항목     |                값                 |
+| :--------- | :------------------------------- |
+| 문자 인코딩 |     `--charactoer-set-server`     |
+|  정렬 순서  |       `--collation-server`        |
+|  인증 방식  | `--default-authentication-plugin` |
+
+
+### 워드프레스 컨테이너 실행 시 필요한 옵션과 인자
+
+```sh
+docker run --name <container_name> -dit --net=<network_name> -p <port> -e ... wordpress
+```
+
+#### 옵션
+
+여기도 사용할 수 있는 옵션이 많다.
+
+| 항목                        | 값                          |
+| :-------------------------- | :-------------------------- |
+| 데이터 베이스 컨테이너 이름 | `-e WORDPRESS_DB_HOST`      |
+| 데이터 베이스 이름          | `-e WORDPRESS_DB_NAME`      |
+| 데이터 베이스 사용자 이름   | `-e WORDPRESS_DB_USER`      |
+| 데이터 베이스 비밀번호      | `-e WORDPRESS_DB_PASSSWORD` |
+
+---
+# SECTION 2. 워드프레스 및 MySQL 컨테이너 생성과 연동
+
+```sh
+C:\Users\Kwon>docker run --name mysql000ex11 -dit --net=wp -e MYSQL_ROOT_PASSWORD=1234 -e MYSQL_DATABASE=wordpress---db -e MYSQL_USER=wordpress000user -e MYSQL_PASSWORD=1234 mysql --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --default-authentication-plugin=mysql_native_password
+853dd040ade1fef5532d8429504d7a1b2ab3f0b3cb6f8ed635918d4df773b1b6
+
+C:\Users\Kwon>docker run --name wordpress000ex12 -dit --net=wp -p 8085:80 -e WORDPRESSS_DB_HOST=mysql000ex11 -e WORDPRES
+S_DB_NAME=wordpress000db -e WORDPRESS_DB_USER=wordpress000user -e WORDPRESS_DB_PASSWORD=1234 wordpress
+aef41f135fbdba00fe389a0f882e52aaa05f24f638fbf7ce3277dfc964ea5e79
+
+C:\Users\Kwon>docker ps
+CONTAINER ID   IMAGE       COMMAND                  CREATED          STATUS          PORTS                  NAMES
+aef41f135fbd   wordpress   "docker-entrypoint.s…"   24 seconds ago   Up 21 seconds   0.0.0.0:8085->80/tcp   wordpress000ex12
+```
+
+책과 똑같이 작성했는데도 mysql이 실행이 정상적으로 되지 않아 log를 확인해봤다.
+
+```sh
+C:\Users\Kwon>docker logs mysql000ex11
+2024-12-09 06:59:03+00:00 [Note] [Entrypoint]: Entrypoint script for MySQL Server 9.1.0-1.el9 started.
+2024-12-09 06:59:03+00:00 [Note] [Entrypoint]: Switching to dedicated user 'mysql'
+2024-12-09 06:59:03+00:00 [Note] [Entrypoint]: Entrypoint script for MySQL Server 9.1.0-1.el9 started.
+2024-12-09 06:59:03+00:00 [Note] [Entrypoint]: Initializing database files
+2024-12-09T06:59:03.712828Z 0 [System] [MY-015017] [Server] MySQL Server Initialization - start.
+2024-12-09T06:59:03.715059Z 0 [System] [MY-013169] [Server] /usr/sbin/mysqld (mysqld 9.1.0) initializing of server in progress as process 80
+2024-12-09T06:59:03.733272Z 1 [System] [MY-013576] [InnoDB] InnoDB initialization has started.
+2024-12-09T06:59:04.187540Z 1 [System] [MY-013577] [InnoDB] InnoDB initialization has ended.
+2024-12-09T06:59:05.435282Z 0 [ERROR] [MY-000067] [Server] unknown variable 'default-authentication-plugin=mysql_native_password'.
+2024-12-09T06:59:05.435689Z 0 [ERROR] [MY-013236] [Server] The designated data directory /var/lib/mysql/ is unusable. You can remove all files that the server added to it.
+2024-12-09T06:59:05.435725Z 0 [ERROR] [MY-010119] [Server] Aborting
+2024-12-09T06:59:06.816914Z 0 [System] [MY-015018] [Server] MySQL Server Initialization - end.
+```
+
+~~`default-authentication-plugin`이 없단다. 여기저기 찾아봤지만 아직 답을 찾지 못해 일단 제거하고 진행한다.~~
+
+```sh
+C:\Users\Kwon>docker run --name mysql000ex11 -dit --net=wp -e MYSQL_ROOT_PASSWORD=1234 -e MYSQL_DATABASE=wordpress---db
+-e MYSQL_USER=wordpress000user -e MYSQL_PASSWORD=1234 mysql:8 --character-set-server=utf8mb4 --collation-server=utf8mb4_
+unicode_ci --default-authentication-plugin=mysql_native_password
+686dada7cdad34fca5dbf41bd22e4f870a449293a9bccdcaf56f883f22ce2775
+
+C:\Users\Kwon>docker ps
+CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                 NAMES
+686dada7cdad   mysql:8   "docker-entrypoint.s…"   8 seconds ago   Up 5 seconds   3306/tcp, 33060/tcp   mysql000ex11
+```
+책과 버전을 맞춰주니 된다. mysql 8 버전으로 진행해야 한다.
+
+```sh
+C:\Users\Kwon>docker run --name mysql000ex11 -dit --net=wp -e MYSQL_ROOT_PASSWORD=1234 -e MYSQL_DATABASE=wordpress---db -e MYSQL_USER=wordpress000user -e MYSQL_PASSWORD=1234 mysql --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
+bd36ad18cacf2d5cb868c6007b3b73272477a5dc39e9b52e374fdd84cb1cd51b
+
+C:\Users\Kwon>docker ps
+CONTAINER ID   IMAGE       COMMAND                  CREATED          STATUS          PORTS                  NAMES
+bd36ad18cacf   mysql       "docker-entrypoint.s…"   11 seconds ago   Up 11 seconds   3306/tcp, 33060/tcp    mysql000ex11
+aef41f135fbd   wordpress   "docker-entrypoint.s…"   41 minutes ago   Up 41 minutes   0.0.0.0:8085->80/tcp   wordpress000ex12
+```
+
+정상적으로 실행되는 것을 확인할 수 있다.
+---
+
+# SECTION 3. 명령어를 직접 작성하자
+
+## SW와 DB의 관계
+
+워드프레스를 사용하려면 워드프레스 프로그램 외에도 아파치와 PHP 런타임, MySQL이 필요했다.
+워드프에스 외에도 이러한 형식으로 구성되는 웹 시스템이 많다.
+
+특히 아파치, PHP, MySQL에 리눅스를 합친 조합은 **LAMP 스택**이라고 부른다.
+SW가 발전하면서 아파치가 nginx로 바뀌기도 하고, MySQL이 MariaDB나 PosetgreSQL로 바뀐 조합도 나타났지만
+'**리눅스 + 웹서버 + 프로그래밍 언어 런타임 + 데이터베이스**'의 조합임은 변함이 없다.
+
+따라서 컨테이너도 '프로그램 본체 + 프로그램 런타임 + 웹 서버' 컨테이너와 '데이터베이스' 컨테이너로 구성해 운령하는 사례를 흔히 볼 수 있다.
+
+글이 길어짐에 따라 포스팅에서는 실습을 제외하도록 한다. 워드프레스 - MySQL과 거의 비슷한 과정으로 진행된다.
\ No newline at end of file
diff --git a/_posts/2024-12-12-dockerCH6.markdown b/_posts/2024-12-12-dockerCH6.markdown
new file mode 100644
index 00000000000..4dd37bc60e4
--- /dev/null
+++ b/_posts/2024-12-12-dockerCH6.markdown
@@ -0,0 +1,272 @@
+---
+title: "CH6. 컨테이너와 호스트 간에 파일 복사하기 [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-12-12T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 2. 컨테이너와 호스트 간에 파일 복사하기
+
+## 파일 복사
+
+> 프로그램만으로 구성된 시스템은 그리 많지 않다.
+
+5장에서도 나왔듯이 프로그램 외에도 프로그래밍 언어의 런타임이나 웹 서버, 데이터베이스 등이 함께 시스템을 구성한다.
+
+이들은 시스템이 동작하는 데 필요하지만, 그 외에도 화면을 구성하는 이미지, 입력받은데이터 본체 등이 있을 수 있다.
+이러한 파일은 서버에 저장되기도 하지만 때로는 SW의 개입 없이 서버와 로컬 컴퓨터 간에 파일을 주고방아야 할 때가 있다.
+이럴 때를 위해 파일 복사하는 방법을 알아둬야 한다.
+
+### `docker cp(container cp)`
+
+```sh
+docker cp 호스트_경로 컨테이너_이름:컨테이너_경로
+docker cp 컨테이너_이름:컨테이너_경로 호스트_경로
+
+docker cp 원본_경로 복사할_경로
+```
+
+### 실습
+
+```html
+<html>
+    <meta chrset="utf-8"/>
+    <body>
+        <div>안녕하세요!</div>
+    </body>
+</html>
+```
+
+```sh
+C:\Users\Kwon>docker run --name apa000ex19 -d -p 8089:80 httpd
+4c037b31d34ea7c0b500b3f84b53b67e04eb1d466ebb0be26dfa6c655b0df72b
+
+C:\Users\Kwon>docker cp C:\Users\Kwon\Desktop\repositories\SSAFY-Docker-Study\members\kwon\index.html apa000ex19:/usr/local/apache2/htdocs/
+Successfully copied 2.05kB to apa000ex19:/usr/local/apache2/htdocs/
+```
+
+위 html 파일을 복사해서 localhost에 접속해보면 아래와 같이 화면이 나오는 것을 확인할 수 있다.
+
+![](/posting_imgs/ch6-1.png){: width="70%"}
+
+인코딩이 문제가 생겼는데... 일단 html에 대해 다루는 것이 목적이 아니므로 넘어가도록 하자.
+
+
+# SECTION 3. 볼륨 마운트
+
+> 볼륨이란 **스토리지의 한 영역을 분할한 것**
+
+볼륨 마운트란 이런 볼륨을 연결하여 운령체제 또는 소프트웨어의 관리하게 두는 일을 말한다.
+
+컨테이너는 쓰고 버리는 것이라 이 내부에 데이터가 있다면, 언젠가는 삭제되기 마련이다.
+데이터가 이렇게 사라지는 것을 막기 위해 마운트를 해서 외부에 데이터를 안전하게 보관한다. (Data persistency)
+
+### Data Persist
+> "Data Persist"는 데이터를 "영구적으로 저장하거나 유지"하는 것을 의미한다.
+> 
+> 이는 주로 휘발성 데이터(예: 메모리에만 존재하는 데이터)와 반대되는 개념으로 영구적인 저장소(예:하드웨어)에 데이터를 저장하여 시스템이 재시작하거나 전원 종료 이후에도 데이터가 사라지지 않는 것을 뜻한다.
+
+
+## Storage Mount
+
+도커에서 스토리지 마운트는 두 가지 종류가 있다.
+
+### Volmune Mount
+
+볼륨 마운트는 도커 엔진이 관리하는 영력 내에 만들어진 볼륨을 컨테이너에 디스크 형태로 마운트한다.
+
+이름만으로 관리가 가능하므로 다루기 쉽지만 볼륨에 비해 **직접 조작하기 어려우므로** '임시 목적의 사용'이나
+'자주 쓰지는 않지만 지우면 안 되는 파일'을 목적으로 많이 사용한다.
+
+### Bind Mount
+
+바인드 마운트는 도커가 설치된 컴퓨터의 문서 폴더 등의 도커 엔진에서 관리하지 않는 영역의 기존 디렉터리를 컨테이너에 마운트 하는 방식이다.
+파일 단위 마운트도 가능하다.
+
+폴더 속에 파일을 직접 넣어두거나 열어 볼 수 있기 때문에 **자주 사용하는 파일**을 두는 데 사용한다.
+
+| 항목          | 볼륨 마운트             | 바인트 마운트                |
+| :------------ | :---------------------- | :--------------------------- |
+| 스토리지 영역 | 볼륨                    | 디렉터리 또는 파일           |
+| 물리적 위치   | 도커 엔진의 관리 영역   | 어디든지 가능                |
+| 마운트 절차   | 볼륨을 생성한 후 마운트 | 기존 파일 또는 폴더를 마운트 |
+| 내용 편집     | 도커 컨테이너를 통해    | 일반적인 파일과 같이         |
+| 백업          | 절차가 복잡함           | 일반적인 파일과 같이         |
+
+파일을 직접 편집해야 할 일이 많다면 바인드 마운트를, 그렇지 않다면 볼륨 마운트를 사용하면 된다.
+
+### 스토리지 영역을 마운트하는 커맨드
+
+run 커맨드의 옵션 형태로 지정한다.
+
+마운트 이전에 volume을 먼저 만들어야 한다.
+
+```sh
+# 생성
+docker volume create volume_name
+# 삭제
+docker volume rm volume_name
+# 상세정보
+docker volume inspect volume_name
+# 목록
+docker volume ls
+# 마운트되지 않은 볼륨 모두 삭제
+docker volume prune
+```
+
+이후 스토리지를 마운트한다
+
+```sh
+# 바인드 마운트
+-v 스토리지_실제_경로:컨테이너_마운트_경로
+# 볼륨 마운트
+-v 볼륨_이름:컨테이너_마운트_경로
+```
+---
+
+# SECTION 4. 컨테이너로 이미지 만들기
+
+## 이미지 만들기
+### commit 커맨드로 컨테이너를 이미지로 변환
+
+```sh
+docker commit container_name new_image_name
+```
+
+### Dockerfile 스크립트로 이미지 만들기
+
+Dockerfile 스크립트에는 토대가 될 이미지나 실행할 명령어 등을 기제한다.
+
+이 파일을 호스트 컴퓨터의 이미지 재료가 들어있는 폴더에 넣는다. 재료 폴더에는 그 외 컨테이너에 넣을 파일을 함께둔다.
+
+```sh
+docker build -t new_image_name 재료_폴더_경로
+```
+
+```Dockerfile
+FROM 이미지_이름
+COPY 원본_경로 대상_경로
+RUN 리눅스_명령어
+...
+```
+
+| 인스트럭션    | 내용 |
+| :------------ | :--- |
+| `FROM`        |토대가 되는 이미지를 지정|
+| `ADD`         |이미지에 파일이나 폴더를 추가|
+| `COPY`        |이미지에 파일이나 폴더를 복사|
+| `RUN`         |이미지를 빌드할 때 실행할 명령어 지정|
+| `CMD`         |컨테이너를 실행할 때 실행할 명령어 지정|
+| `ENTRYPOINT`  |컨테이너를 실행할 때 실행할 명령어 강제 지정|
+| `ONBUILD`     |이 이미지를 기반으로 다른 이미지를 빌드할 때 실행할 명령어를 지정|
+| `EXPOSE`      |이미지가 통신에 사용할 포트를 명시적으로 지정|
+| `VOLUME`      |persistency data를 저장할 경로를 명시적으로 지정|
+| `ENV`         |환경변수 정의|
+| `WORKDIR`     |`RUN`, `CMD`, `ENTRYPOINT`, `ADD`, `COPY`에 정의된 명령어를 실행하는 작업 디렉터리를 지정|
+| `SHELL`       |빌드 시 사용할 shell을 변경|
+| `LABEL`       |이름이나 버전, 저작자 정보를 설정|
+| `USER`        |`RUN`, `CMD`, `ENTRYPOINT`에 정의된 명령어를 실행하는 사용자 또는 그룹을 지정|
+| `ARG`         |`docker build` 커맨드를 사용할 때 입력받을 수 있는 인자를 선언|
+| `STOPSIGNAL`  |`docker build` 커맨드를 사용할 때 컨테이너 안에서 실행 중인 프로그램에 전달되는 시그널을 변경|
+| `HEALTHCHECK` |컨테이너 health check 방법을 커스터마이징|
+
+
+## 이미지 옮기기
+
+컨테이너는 먼저 이미지로 변환하지 않으면 옮기거나 복사할 수 없다. 하지만 이미지 역시 이미지 상태 그대로는 옮기거나 복사할 수 없으므로 도커 레지스트리를 통하거나
+`save` 커맨드를 사용해 tar 포맷으로 도커 엔진의 관리 영역 밖으로 내보내야 한다. 파일은 호스트 컴퓨터의 파일 시스템에 생성된다.
+파일을 다시 도커 엔진에 가져 오려면 `load` 커맨드를 사용한다.
+```sh
+docker save -o file_name.tar image_name
+```
+---
+
+# SECTION 5. 컨테이너 개조
+
+도커를 실제 운용하는 현장에서는 사내에서 개발한 시스템을 운영하는 경우가 많다.
+사내 개발 시스템이 아니더라도 공식 배포되는 SW 역시 수정해야 할 필요가 종종 있다.
+
+컨테이너를 개조하는 방법에는 두 가지 방법이 있으며, 대부분 이를 혼용하여 사용한다.
+
+1. 파일 복사와 마운트를 사용하는 방법
+2. 컨테이너에서 리눅스 명령어를 실행하는 방법
+
+### container에서 명령어 실행
+
+container의 bash에 접근해 명령을 실행하기 위해서는 `/bin/bash` 인자를 사용한다.
+
+```sh
+docker exec (options) container_name /bin/bash
+docker run (options) image_name /bin/bash
+```
+
+container가 이미 실행 중이라면 `exec`를 사용해서 접근하고, 새로 시작하는 경우 run으로 실행한다.
+
+하지만 `run`에 인자를 붙여 사용하는 경우 컨테이너에 들어있는 SW(아파치 같은)를 실행하는 대신 bash가 실행된다.
+그래서 container는 실행 중인데 SW는 실행 중이 아닌 상태가 된다. 즉, bash 조작이 끝나고 **다시 `docker start`로 재시작**해야 한다.
+
+```sh
+docker exec -it apa000ex23 /bin/bash
+
+# 아파치 실행 안됨
+docker run --name apa000ex23 -it -p 8089:80 httpd /bin/bash
+
+# 나가기
+exit
+```
+
+이런 식으로 사용할 수 있다. 이렇게 bash에 접근하면 container에 직접 명령을 내릴 수 있게 된다.
+
+### 도커 엔진을 통한 명령과 컨테이너 내부에서 실행하는 명령
+
+|          도커 엔진          | 컨테이너 내부  |
+| :-------------------------: | :------------: |
+|   도커 엔진의 시작 / 종료   |    SW 설치     |
+|   컨테이너의 시작 / 종료    | SW 실행 / 종료 |
+| 컨테이너 안팎의 파일을 복사 |  SW 설정 변경  |
+|                             |   파일 작업    |
+---
+
+
+# SECTION 6. 도커 허브 로그인
+
+> 직접 만든 이미지도 도커 허브에 올릴 수 있으며, 비공개로 사용하는 도커 허브 같은 장소도 만들 수 있다.
+
+## 도커 허브와 레지스트리
+
+이미지를 배포하는 장소를 **도커 레지스트리**라고 한다.
+일반에 공개되어 있든 말든 상관없이 이미지가 배포되는 곳은 모두 도커 레지스트리이다.
+
+도커 허브는 도커 제작사에서 운영하는 공식 도커 레지스트리를 말한다.
+우리가 `run` 커맨드를 사용할 때 내려받는 이미지는 이렇게 제공된다.
+
+### 레지스트리와 리포지토리
+
+레지스트리는 이미지를 배포하는 장소이고, 리포지토리는 레지스트리를 구성하는 단위이다.
+
+즉 레지스트리는 회사나 부서 단위로 만들지만, 리포지토리는 SW를 단위로 한다.
+
+---
+
+## 태그와 이미지 업로드
+
+태그는 다음과 같은 형태를 띈다
+
+```sh
+resistry_addr(docker_hub_id)/reporitory_name:ver
+```
+
+태그 부여는 다음과 같이 한다.
+
+```sh
+docker tag 원래_이미지_이름 레지스트리_주소/리포지토리_이름:버전
+```
+
+이미지를 업로드 할 때는 `push`를 사용한다.
+
+```sh
+docker push 레지스트리_주소/리포지토리_이름:버전
+```
\ No newline at end of file
diff --git a/_posts/2024-12-12-dockerCH7.markdown b/_posts/2024-12-12-dockerCH7.markdown
new file mode 100644
index 00000000000..c8a5c105b32
--- /dev/null
+++ b/_posts/2024-12-12-dockerCH7.markdown
@@ -0,0 +1,300 @@
+---
+title: "CH7. 도커 컴포즈를 익히자 [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-12-12T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 1. 도커 컴포즈란?
+
+## 도커 컴포즈
+
+시스템 구축과 관련된 명령어를 하나의 텍스트 파일(정의 파일)에 기재해
+명령어 한번에 시스템 전체를 실행하고 종료와 폐기까지 한번에 하도록 도와주는 도구이다.
+
+![](/posting_imgs/docker-compose1.png)
+
+### 구조
+
+docker compose는 시스템 구축에 필요한 설정을 YAML(YAML Ain't Markup Language) 포멧으로 기재한 정의 파일을 이용해 전체 시스템을 일괄 실행(`run`) 또는 일괄 종료 및 삭제(`down`)할 수 있는 도구다.
+
+정의 파일에는 컨테이너나 볼륨을 어떤 설정으로 만들지에 대한 항목이 기재되어 있다.
+작성 내용은 도커 명령어롸 비슷하지만 도커 명령어가 아니다.
+
+#### `up`
+`docker run`과 비슷하다, 정의 파일에 기재된 내용대로 이미지를 내려받고 컨테이너를 생성 및 실행한다.
+정의 파일에는 네트워크나 볼륨에 대한 정의도 기재할 수 있어서 주변 환경을 한꺼번에 생성할 수 있다.
+
+#### `down`
+컨테이너와 네트워크를 정지 및 삭제한다.
+**볼륨과 이미지는 삭제하지 않는다**. 컨테이너와 네트워크 삭제 없이 종료만 하고 싶다면 stop 커맨드를 이용한다.
+
+docker compose가 Dockerfile 스크립트와 비슷하게 느껴질 수 있다.
+하지만 Dockerfile은 이미지를 만들기 위한 것으로 **네트워크나 볼륨은 만들 수 없다.**
+반면, docker compose는 docker run 명령어를 여러 개 모아놓은 것과 같은 것으로,
+**네트워크와 볼륨까지 함께 만들 수 있다.**
+
+---
+
+# SECTION 2. 도커 컴포즈의 설치와 사용법
+
+## docker compose의 설치
+도커 컴포즈는 토커 엔진과 별개의 SW이므로 설치를 따로 해줘야 한다.
+윈도우나 mac OS에서 사용하는 docker desktop은 docker compose가 함께 설치되므로 신경 쓸 필요 없다.
+리눅스의 경우 아래의 명령어에 따라 설치를 진행한다.
+
+```sh
+sudo apt install -y python3 python3-pip
+sudo pip3 install docker-compose
+```
+
+## docker compose의 사용법
+
+docker compose를 사용하려면 Dockerfile 스크립트로 이미지를 빌드할 때처럼 호스크 컴퓨터에 폴더를 만들고 이 폴더에 정의 파일(YAML)을 배치한다.
+
+정의 파일은 docker-compose.yml이라는 이름으로 만들어야 한다.
+파일은 호스트 컴퓨터에 배치되지만 명령어는 똑같이 도커 엔진에 전달되며, 만들어진 컨테이너도 동일하게 도커 엔진 위에서 동작한다.
+즉, 사람이 입력해던 명령어들을 docker compose가 대신 입력해주는 구조다.
+
+정의 파일은 한 폴더에 하나만 있을 수 있다.
+그래서 여러 개의 정의 파일을 사용하려면 그 개수만큼 폴더를 만들어야 한다.
+컨테이너 생성에 필요한 이미지 파일과 같은 부가적인 파일도 compose가 사용할 폴더에 함께 둔다.
+
+---
+
+# SECTION 3. 도커 컴포즈 파일을 작성하는 법
+
+## docker compose의 내용
+
+```yml
+version: "3"
+
+sevices:
+    apa000ex2:
+        image: httpd
+        ports:
+            - 8080:80
+        restart: always
+```
+
+이 docker compose 파일은 아래 명령어와 같은 내용을 담고 있다.
+
+```sh
+docker run --name apa000ex2 -d -p 8080:80 httpd
+```
+
+전체적인 구조는 다음과 같다.
+
+```yml
+version: "3"
+
+sevices:
+    container_name1:
+        image: image_name
+        networks:
+            - network_name
+        ports:
+            - port_setting
+    container_name2:
+
+networks:
+    network_name1:
+volumes:
+    volume_name1:
+    volume_name2:
+```
+
+### compose 파일 작성 요령 정리
+
+- 첫 중에 docker compose version을 기재
+- 주 항목 services, networks, volumes 아래에 설정 내용을 기재
+- 항목 간의 상하 관계는 공백을 사용한 들여쓰기로
+- 들여쓰지는 같은 수의 배수만큼의 공백을 사용
+- 이름은 주 항목 아래에 들여쓰기 한 다음 기재
+- 여러 항목을 기재하려면 출 앞에 '-'을 붙임
+- 이름 뒤에는 ':'을 붙임
+- 콜론 뒤에는 반드시 공백이 와야 함
+- \# 뒤의 내용은 주석으로 간주
+- 문자열은 작은/큰따옴표로 감싸 작성
+
+### compose 파일의 항목
+
+#### 주 항목
+
+| 항목     | 내용          |
+| :------- | :------------ |
+| services | 컨테이너 정의 |
+| networks | 네트워크 정의 |
+| volumes  | 볼륨 정의     |
+
+#### 자주 나오는 정의 내용
+
+| 항목        | `docker run`에서의 옵션 / 인자 | 내용                                |
+| :---------- | :----------------------------- | :---------------------------------- |
+| image       | 이미지 인자                    | 사용할 이미지 지정                  |
+| networks    | `--net`                        | 접속할 네트워크 설정                |
+| volumes     | `-v`, `--mount`                | 스토리지 마운트 성정                |
+| environment | `-e`                           | 환경변수 설정                       |
+| depends_on  | -                              | 다른 서비스에 대한 의존관계를 정의  |
+| restart     | -                              | 컨테이너 종료 시 재시작 여부를 설정 |
+
+#### restart 설정값
+
+| 설정값         | 내용                                       |
+| :------------- | :----------------------------------------- |
+| no             | 재시작 안함                                |
+| always         | 항상 재시작                                |
+| on-failure     | 프로세스가 0 이외의 상태로 종료되면 재시작 |
+| unless-stopped | 종료 시 재시작하지 않음. 이외에는 재시작   |
+
+## 실습
+
+### docker-compose.yml
+```yml
+version: "3.8"
+services:
+  postgres:
+    build:
+      context: .
+      dockerfile: Dockerfile.postgres  # postgres용 Dockerfile
+    container_name: backend
+    environment:
+      POSTGRES_DB: rag
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+    working_dir: /home
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - .:/home/app
+    ports:
+      - "5430:5432"
+    stdin_open: true
+    tty: true
+    command: tail -f /dev/null
+    # restart: unless-stopped
+
+  vue:
+    build:
+      context: .
+      dockerfile: Dockerfile.vue  # vue용 Dockerfile
+    container_name: frontend
+    network_mode: host
+    working_dir: /app
+    volumes:
+      - .:/app  # 로컬 디렉토리를 컨테이너에 마운트
+    ports:
+      - "5173:5173"
+    stdin_open: true
+    tty: true
+
+volumes:
+  postgres_data:
+```
+
+### Dockerfile.postgres
+```Dockerfile
+# 베이스 이미지 선택
+FROM kwon0528/postgres_backend:0.5
+
+# 필요한 패키지 설치 (bash 설치)
+RUN apt-get update && apt-get install -y bash
+
+# 작업 디렉토리 설정
+WORKDIR /home
+
+# back.sh 파일 복사
+COPY back.sh /home/back.sh
+
+# 실행 권한 부여
+RUN chmod +x /home/back.sh
+
+# 실행
+CMD ["bash", "/home/back.sh"]
+```
+
+
+### Dockerfile.vue
+```Dockerfile
+# 베이스 이미지 선택
+FROM kwon0528/vue_frontend:0.3.2
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# # front.sh 파일 복사
+# COPY front.sh /app/chuibot/front.sh
+
+# # 실행 권한 부여
+# RUN chmod +x /app/chuibot/front.sh
+
+# # 실행
+# CMD ["sh", "/app/front.sh"]
+# CMD cd ~/chuibot && git pull
+```
+
+실제 postgresql과 vue를 사용한 프로젝트에서 환경 설정을 위해 구성했던 docker compose이다.
+위에서 알아본 것과 다른 점은 image를 바로 명시하지 않고 Dockerfile을 기반으로 build를 구성했다는 것이다.
+
+이처럼 docker compose 안에서도 Dockerfile을 사용하여 구성할수도 있다.
+
+---
+
+# 도커 컴포즈 실행
+
+## docker compose command
+
+### `docker-compose up`
+
+```sh
+docker-compose -f compose_file_path up
+```
+
+compose 파일의 내용에 따라 컨테이너와 볼륨, 네트워크를 생성하고 실행한다.
+
+#### 옵션 항목
+
+| 옵션                        | 내용                                                 |
+| --------------------------- | ---------------------------------------------------- |
+| `-d`                        | 백그라운드로 실행                                    |
+| `--no-color`                | 화면 출력 내용을 흑백으로 함                         |
+| `--no-deps`                 | 링크된 서비스를 싱행하지 않음                        |
+| `--force-recreate`          | 설정 또는 이미지가 변경되지 않아도 컨테이너 재생성   |
+| `--no-create`               | 컨테이너가 이미 존재할 경우 다시 생성하지 않음       |
+| `--no-build`                | 이미지가 없어도 이미지를 빌드하지 않음               |
+| `--build`                   | 컨테이너를 실행하기 전에 이미지를 빌드               |
+| `--abort-on-container-exit` | 컨테이너가 하나라도 종료되면 모든 컨테이너를 종료    |
+| `-t`, `--timeout`           | 컨테이너를 졸요할 때의 타임아웃 설정. 기본은 10초    |
+| `--remove-orphans`          | 컴포즈 파일에 섲의되지 않은 서비스의 컨테이너를 삭제 |
+| `--scale`                   | 컨테이너 수 변경                                     |
+
+### `docker-compose down`
+
+```sh
+docker-compose -f compose_file_path down
+```
+
+compose 파일의 내용에 따라 컨테이너와 네트워크를 종료 및 삭제한다. 볼륨과 이미지는 삭제되지 않는다.
+
+#### 옵션 항목
+
+| 옵션               | 내용                                                                                                                                      |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `-rmi` 종류        | 삭제 시에 이미지도 삭제한다. 종류를 all로 지정하면 사용했던 모든 이미지가 삭제된다. local로 지정하면 커스텀 태그가 없는 이미지만 삭제된다 |
+| `-v`, `--volume`   | volumes 항목에 기재된 볼륨을 삭제한다. 단, external로 지정된 볼륨은 삭제되지 않는다.                                                      |
+| `--remove-orphans` | 컴포즈 파일에 정의되지 않은 서비스의 컨테이너도 삭제한다.                                                                                 |
+
+### `docker-compose stop`
+
+```sh
+docker-compose -f compose_file_path stop <option>
+```
+
+compose 파일의 내용에 따라 컨테이너와 네트워크를 종료한다.
+
+---
+
+앞서 실습으로 작성했던 compose 파일을 `up`으로 실행하면 postgresql 환경에 django를 쓸 수 있도록 backend container가 실행되고,
+vue 환경으로 frontend container가 실행된다.
\ No newline at end of file
diff --git a/_posts/2024-12-12-dockerCH8.markdown b/_posts/2024-12-12-dockerCH8.markdown
new file mode 100644
index 00000000000..51946ba3ce6
--- /dev/null
+++ b/_posts/2024-12-12-dockerCH8.markdown
@@ -0,0 +1,176 @@
+---
+title: "CH8. 쿠버네티스를 익히자 [그림으로 배우는 도커 & 쿠버네티스]"
+author: kwon
+date: 2024-12-12T14:00:00 +0900
+categories: [도커]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# SECTION 1. 쿠버네티스란?
+
+## 쿠버네티스
+
+> **Kubernetes**는 컨테이너 오케스트레이션 도구이다.
+
+컨테이너 오케스트레이션이란 시스템 전체를 통괄하고 여러 개의 컨테이너를 관리하는 일을 말한다.
+쿠버네티스는 **k8s**라고 줄여 쓰기도 한다. k와 s 사이에 8개의 글자가 있다는 의미로, 쿠버네티스와 관련된 검색어로 유용하다.
+
+최근 쿠버네티스가 유행을 타고는 있지만 그 본질상 일반적인 프로그래머가 쿠버네티스를 활발하게 사용할 일은 많지 않다.
+왜냐하면 여러 개의 컨테이너(=서버)를 관리하는 도구이기 때문이다.
+즉 많은 수의 서버로 구성되는 대규모 시스템을 관리하는 경우 사용되는 것이다.
+
+하지만 쿠버네티스로 어떤 일을 할 수 있는가에 대한 지식은 시스템을 개발할 때 유용할 수 있다.
+쿠버네티스로 관리되는 시스템은 이를 전제로 개발해야 한다.
+
+쿠버네티스는 여러 대의 물리적 서버가 존재하는 것을 전제로 한다.
+그리고 이 서버 한 대 한 대마다 여러 대의 컨테이너를 실행한다.
+이런 환경에서 쿠버네티스는 컨테이너의 생성이나 관리의 수고를 덜어주는 역할을 한다.
+
+# SECTION 2. 마스터 노드와 워커 노드
+
+쿠버네티스는 전체적인 제어를 담당하는 **마스터 노드**와 실제 동작을 담당하는 **워커 노드**라는 두 가지 유형의 노드로 구성된다.
+
+마스터 노드는 워커 노드에서 실행되는 컨테이너를 관리하는 역할을 한다.
+마스터 노드에서는 **컨테이너를 실행하지 않기** 때문에 도커 엔진과 같은 컨테이너 엔진도 설치되지 않는다.
+
+워커 노드는 실제 서버에 해당하는 부분으로 컨테이너가 실제 동작하는 서버이다.
+컨테이너가 동작해야 하므로 컨테이너 엔진이 설치되어야 한다.
+
+이렇게 마스터 노드와 워커 노드로 구성된 일군의 구버네티스 시스템을 **클러스터**라고 한다.
+클러스터는 사람이 개입하지 않아도 마스터 노드에 설정된 내용에 따라 워커 노드가 관리되며 자율적으로 동작한다.
+
+![](./images/kubernetes_cluster.png)
+
+쿠버네티스는 컨테이너 엔진과는 별개의 SW이므로 따로 설치가 필요하다.
+쿠버네티스 SW와 CNI(가상 네트워크 드라이버, Container Network Interface)를 설치해야 한다.
+대표적인 CNI로 flannel, Calico, AWS VPC CNI 등이 있다.
+
+마스터 노드에는 컨테이너 등의 상태를 관리하기 위해 etcd라는 데이터베이스가 설치된다.
+또한 마스터 노드를 설정하는 관리자의 컴퓨터에는 kubectl을 설치하여 마스터 노드에 로그인 및 초기 설정, 추후 조정을 한다.
+워커 노드에는 물론 도커 엔진 같은 컨테이너 엔진이 필요하다.
+
+\* 가상 네트워크: 도커의 가상 네트워크는 같은 물리적 컴퓨터 안에서의 네트워크이며,
+쿠버네티스에서의 가상 네트워크는 오버레이 네트워크로 다른 물리적 컴퓨터를 같은 로컬 네트워크로 묶기 위해 사용한다.
+
+\* etcd: key-value store 타입의 데이터베이스로 이 밖의 다른 목적으로도 사용된다.
+
+---
+
+## 컨트롤 플레인(제어판)과 kube-let
+
+마스터 노드는 컨트롤 플레인을 통해 워커 노드를 관리한다.
+컨트롤 플레인은 아래 다섯 가지의 컴포넌트로 구성된다.
+
+| 항목                     | 내용                                                              |
+| ------------------------ | ----------------------------------------------------------------- |
+| kube-apiserver           | 외부와 통신하는 프로세스, kubectl로부터 명령을 전달받아 실행한다. |
+| kube-controll-manager    | 컨트롤러를 통합 관리 실행한다.                                    |
+| kube-scheduler           | 파드를 워커 노드에 할당한다.                                       |
+| cloud-controller-manager | 클라우드 서비스와 연돌해 서비스를 생성한다.                        |
+| etcd                     | 클러스터 관련 정보 전반을 관리하는 데이터베이스                   |
+
+etcd를 제외하고 모두 쿠버네티스에 포함되어 있으므로 추가로 설치할 필요는 없다.
+
+워커 노드에서는 아래 요소들로 구성되어 있다.
+
+| 항목       | 내용                                                                                                                                                           |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| kube-let   | 마스터노드에 있는 kube-scheduler와 연동하며 워커 노드에 파드를 배치하고 실행한다. 또 실행 중인 파드의 상태를 정기적으로 모니터링하며 kube-scheduler에 통지한다 |
+| kube-proxy | 네트워크 통신의 라우팅 메커니즘 |
+
+kube-let은 마스터 노드의 kube-scheduler와 연동하며 워커 노드에 컨테이너 또는 볼륨을 배치하고 실행한다.
+이들도 쿠버네티스에 포함되어 있다.
+
+---
+> 쿠버네티스는 항상 '바람직한' 상태를 유지한다.
+
+쿠버네티스도 컨테이너를 생성하거나 삭제할 수 있지만 일일이 명령어를 입력하는 방식을 사용하지는 않는다.
+어떠한 '바람직한 상태'를 YAML 파일에 정의하고, 자동으로 컨테이너를 생성하거나 삭제하면서 이 상태를 만들고 유지하는 것이 쿠버네티스의 기본적인 아이디어이다.
+
+docker compose는 모니터링 기능이 없어 컨테이너를 만들 때 외에는 관여하지 않는다.
+반면 쿠버네티스는 '**이 상태를 유지**'하는 기능이 있다.
+
+그러므로 어떤 이유로 컨테이너가 망가지면 쿠버네티스가 알아서 말가진 컨테이너를 삭제하고 새 컨테이너로 대체하며,
+정의에서 '컨테이너 5개'를 '컨테이너 4개'로 수정하면 컨테이너 하나를 삭제한다.
+
+만약 사용자가 컨테이너를 명령어로 삭제한다면 쿠버네티스는 자동으로 컨테이너를 새로 만들어 채우려고 할 것이므로,
+파일에서 '바람직한 상태'를 수정해야 한다.
+
+---
+
+# SECTION 3. 쿠버네티스의 구성과 관련 용어
+
+## 쿠버네티스의 구성과 관련된 용어
+
+### pod
+
+pod는 컨테이너와 볼륨을 함께 묶은 단위이다. 기본적으로 pod 하나에 컨테이너 하나이지만, 여러개의 컨테이너가 속할 수도 있다.
+
+pod에 포함되는 볼륨은 함께 포함되는 컨테이너가 정보를 공유하기 위해 사용하는 것으로, 볼륨이 없는 경우도 많다.
+
+### service
+
+service는 pod를 모은 것으로, 어러개의 pod를 이끄는 반장으로 생각할 수 있다.
+service가 관리하는 pod는 모두 기본적으로 동일한 구성을 가지며, 구성이 다른 pod는 별도의 service로 관리한다.
+또한 pod가 여러 개의 워커 노드에 걸쳐 동작 하더라고 이들을 모두 관리한다.
+
+service는 로드 밸런서 역할을 한다. 각 service는 자동적으로 고정된 IP 주소(cluster IP)를 부여받으며, 이 주소로 들어오는 통신을 처리한다.
+내부적으로 여러 pod가 있어도 밖에서는 하나의 IP 주소만 볼 수 있으며,
+이 주소로 접근하면 service가 통신을 적절히 분배한다.
+
+하지만 service가 분배하는 통신은 한 워커 노드 안으로 국한된다.
+여러 워크 노드 간의 분배는 실제 로드 밸런서 또는 인그레스가 담당한다.
+이들은 마스터 노드도 워커 노드도 아닌 별도의 노드에서 동작하거나 물리적 전용 하드웨어이다.
+
+![](./images/kube_service.png)
+
+### ReplicaSet, deployment
+
+service가 요청을 배분했다면, ReplicaSet는 pod의 수를 관리한다.
+장애 등의 이유로 pod가 종료되었을 때, 정의 파일에 pod의 수가 바꼈을 때 pod의 수를 실제로 변경한다.
+
+ReplicaSet가 관리하는 동일한 구성의 pod를 replica라고 한다.
+
+ReplicaSet는 원하는대로 다루기가 어렵기 때문에 deployment와 함께 쓰이는 경우가 많다.
+deployment는 pod의 배포를 관리하는 요소로, pod가 가용하는 이미지 등 pod에 대한 정보를 가지고 있다.
+
+### 쿠버네티스 리소스
+
+pod, service, deployment, replicaSet 등을 resource라고 한다.
+쿠버네티스에는 50여 종의 resource기 있으며 실제로 많이 사용되는 것을 아래 표에서 확인할 수 있다.
+
+| resource 이름          | 내용                                     |
+| ---------------------- | ---------------------------------------- |
+| **pods**               | containers + volumes                     |
+| podtemplates           | 배포 시 pod의 틀 역할                    |
+| replicationcontrollers | replication 제어                         |
+| resourcequotas         | 쿠버네티스 resource의 사용향 제한을 설정 |
+| secrets                | 키 정보를 관리                           |
+| serviceaccounts        | resource를 다루는 사용자를 관리          |
+| **services**           | pod에 요청을 배분                        |
+| daemonsets             | 워커 노드마다 하나의 pod를 생성          |
+| **deployments**        | pod 배포 관리                            |
+| replicasets            | pod 수 관리                              |
+| statefulsets           | pod의 배포를 상태를 유지하며 관리        |
+| cronjobs               | 지정된 스케줄대로 pod를 실행             |
+| jobs                   | pod르 한 번 실행                         |
+
+---
+
+# SECTION 4. 쿠버네티스 설치 및 사용법
+
+> 쿠버네티스는 CNCF(Cloud Native Compution Foundation)에서 제장한 표준이다.
+
+쿠버네티스는 구글에서 개발됐지만 구글 등의 회사가 CNCF를 조직하고 이 재단에서 쿠버네티스를 기부해 개발이 오픈소스로 전환되면서 급속하게 보급되었다.
+
+CNCF에서도 쿠버네티스를 만들고 있지만 관리 기능을 강화한 버전이나 크기를 줄인 버전 등 쿠버네티스의 규격을 따른 서드파티 SW 들이 여럿 나오고 있다.
+특히 AWS나 Azure, GCP 같은 클라우드 서비스에서는 자사 서비스에 맞춰 커스터마이징된 쿠버네티스를 제공한다.
+
+원조 쿠버네티스를 채택하는 것은 흔한 일이지만 직접 구축하는 것은 어려운 일이기에, 실습에서는 docker desktop에 포함된 쿠버네티스를 사용한다.
+도커 설정 화면에서 Kubernetes를 체크하면 바로 사용할 수 있다.
+
+리눅스에서는 Minikube라는 간단히 사용할 수 있는 쿠버네티스가 있다.
+Minikube는 원조 쿠버네티스와 달리 컴퓨터 한 대에 마스터 노드와 워커 노드를 모두 구축한다. 즉 물리적 컴퓨터를 따로 둘 필요가 없다.
+
diff --git a/_posts/2025-01-09-boj_11066.markdown b/_posts/2025-01-09-boj_11066.markdown
new file mode 100644
index 00000000000..64fcb80c471
--- /dev/null
+++ b/_posts/2025-01-09-boj_11066.markdown
@@ -0,0 +1,142 @@
+---
+title: "[BOJ] 파일 합치기 - 11066 (G3)"
+author: kwon
+date: 2025-01-09T23:00:00 +0900
+categories: [boj, gold]
+tags: [dynamic programming]
+math: true
+mermaid: false
+---
+
+| 시간 제한 | 메모리 제한 |
+| --- | --- |
+| 2 초 | 256 MB |
+
+# 문제
+소설가인 김대전은 소설을 여러 장(chapter)으로 나누어 쓰는데, 각 장은 각각 다른 파일에 저장하곤 한다. 소설의 모든 장을 쓰고 나서는 각 장이 쓰여진 파일을 합쳐서 최종적으로 소설의 완성본이 들어있는 한 개의 파일을 만든다. 이 과정에서 두 개의 파일을 합쳐서 하나의 임시파일을 만들고, 이 임시파일이나 원래의 파일을 계속 두 개씩 합쳐서 소설의 여러 장들이 연속이 되도록 파일을 합쳐나가고, 최종적으로는 하나의 파일로 합친다. 두 개의 파일을 합칠 때 필요한 비용(시간 등)이 두 파일 크기의 합이라고 가정할 때, 최종적인 한 개의 파일을 완성하는데 필요한 비용의 총 합을 계산하시오.
+
+예를 들어, C1, C2, C3, C4가 연속적인 네 개의 장을 수록하고 있는 파일이고, 파일 크기가 각각 40, 30, 30, 50 이라고 하자. 이 파일들을 합치는 과정에서, 먼저 C2와 C3를 합쳐서 임시파일 X1을 만든다. 이때 비용 60이 필요하다. 그 다음으로 C1과 X1을 합쳐 임시파일 X2를 만들면 비용 100이 필요하다. 최종적으로 X2와 C4를 합쳐 최종파일을 만들면 비용 150이 필요하다. 따라서, 최종의 한 파일을 만드는데 필요한 비용의 합은 60+100+150=310 이다. 다른 방법으로 파일을 합치면 비용을 줄일 수 있다. 먼저 C1과 C2를 합쳐 임시파일 Y1을 만들고, C3와 C4를 합쳐 임시파일 Y2를 만들고, 최종적으로 Y1과 Y2를 합쳐 최종파일을 만들 수 있다. 이때 필요한 총 비용은 70+80+150=300 이다.
+
+소설의 각 장들이 수록되어 있는 파일의 크기가 주어졌을 때, 이 파일들을 하나의 파일로 합칠 때 필요한 최소비용을 계산하는 프로그램을 작성하시오.
+
+# 입력
+프로그램은 표준 입력에서 입력 데이터를 받는다. 프로그램의 입력은 T개의 테스트 데이터로 이루어져 있는데, T는 입력의 맨 첫 줄에 주어진다.각 테스트 데이터는 두 개의 행으로 주어지는데, 첫 행에는 소설을 구성하는 장의 수를 나타내는 양의 정수 K (3 ≤ K ≤ 500)가 주어진다. 두 번째 행에는 1장부터 K장까지 수록한 파일의 크기를 나타내는 양의 정수 K개가 주어진다. 파일의 크기는 10,000을 초과하지 않는다.
+
+# 출력
+프로그램은 표준 출력에 출력한다. 각 테스트 데이터마다 정확히 한 행에 출력하는데, 모든 장을 합치는데 필요한 최소비용을 출력한다.
+
+# 풀이
+
+## 첫 풀이
+처음에는 "소설의 여러 장들이 연속이 되도록 파일을 합쳐나가고" 라는 부분을 제대로 읽지 않아 최소값을 계속 뽑으며 파일을 합치려고 했다.
+그래서 아래처럼 heapq로 접근하여 풀이를 작성했다.
+
+### 코드
+```py
+import heapq
+T = int(input())
+
+for _ in range(T):
+    K = int(input())
+
+    res = 0
+    files = list(map(int, input().split()))
+    heapq.heapify(files)
+
+    while len(files) > 1:
+        a, b = heapq.heappop(files), heapq.heappop(files)
+
+        cur = a + b
+        res += cur
+
+        heapq.heappush(files, cur)
+    
+    print(res)
+```
+
+하지만 파일이 연속이 되도록 합칠 수 없을 뿐더러, 최소값을 뽑으며 파일을 합친다고 해서 전체 비용이 최소가 되는 것이 아니기 때문에 완전히 틀린 접근이었다.
+
+## 정답 풀이
+모든 파일을 합치는 순서를 결정하는 과정은 N 쌍의 괄호를 이용하여 서로 다른 괄호 표현을 구하는 경우의 수인 **카탈란 수**와 유사하다.
+
+아래와 같이 파일을 합치는 순서를 괄호로 묶어보면, K-1 쌍의 괄호로 서로 다른 괄호 표현을 구하는 것과 같음을 확인할 수 있다.
+$$
+(((C1 + C2) + C3) + C4)
+$$
+$$
+((C1 + (C2 + C3)) + C4)
+$$
+$$
+((C1 + C2) + (C3 + C4))
+$$
+$$
+(C1 + ((C2 + C3) + C4))
+$$
+$$
+(C1 + (C2 + (C3 + C4)))
+$$
+
+카탈란 수는 다음과 같이 계산할 수 있다.
+$$
+C_{K-1} = \frac{1}{K}{2K-2\choose K-1}=\frac{(2K-2)!}{(K-1)!(K)!}
+$$
+
+그러므로 $K=4$일 떄, 가능한 병합 순서는 카탈란 수 $C_3=5$와 같다.
+
+이렇게 생각했을 때 문제에서 주어진 최대 값인 500을 적용한다면 그 최대 경우의 수는 $C_{500}\eqsim6.76*10^{298}\div500$으로 말도 안되는 경우의 수를 보여준다.
+
+그래서 2차원 DP 배열을 다음과 정의하여 해결을 시도하였다.
+
+> `dp[i][j]`는 i 번째에서 j 번째까지의 파일을 합치는 데 필요한 비용의 최소값이다.
+
+이 배열을 다음 과정을 통해 갱신한다.
+
+```py
+    ...
+    for i in range(1, K):
+        for j in range(i, K):
+            dp[j - i][j] = float('inf')
+            for k in range(j - i, j):
+                dp[j - i][j] = min(dp[j - i][j], dp[j - i][k] + dp[k + 1][j])
+            dp[j - i][j] += sum_list[j + 1] - sum_list[j - i]
+    ...
+```
+`i`는 현재 확인하는 수열의 길이를 뜻한다. `i`가 2, `j`가 3이라면 `dp`에서 갱신하는 부분은 `dp[0][1]`(0번째에서 1번째), `dp[1][2]`(1번째에서 2번째)이다.
+
+각 시행에서 `dp[j - i][j]`는 `min(dp[j - i][j], dp[j - i][k] + dp[k + 1][j])`로 갱신되는데, 이는 '기존의 값'과 'j - i에서  k번째까지의 파일을 합하는데 필요한 최소 비용과 k + 1에서 j번째까지의 파일을 합하는데 필요한 최소 비용을 합한 것' 중 작은 것을 취한다는 의미이다. 이렇게 하면 기존의 모든 구간에서의 최소 비용을 고려하면서 배열을 갱신할 수 있다.
+
+모든 비교가 끝난 후 해당 구간을 마지막으로 병합하는 데 필요한 비용을 더해준다. 이 비용은 누적합을 이용한다.
+`sum_list`에 누적합을 미리 계산해두면 `sum_list[j + 1] - sum_list[j - i]`만 계산하여 j - i 번째에서 j 번째까지 파일을 병합할 때 발생하는 마지막 비용을 구할 수 있다. 마지막에는 무조건 해당 구간의 모든 수를 더한 만큼 비용이 발생하기 때문이다.
+
+그렇게 계산을 하고 나면 `40 30 30 50`의 예시에서 dp 배열은 다음과 같이 완성된다.
+
+![](/posting_imgs/boj_11066.png){: width="60%"}
+
+### 코드
+
+```python
+import heapq
+T = int(input())
+
+for _ in range(T):
+    K = int(input())
+
+    res = 0
+    files = list(map(int, input().split()))
+    
+    dp = [[0] * K for _ in range(K)]
+    sum_list = [0] * (K + 1)
+
+    # 누적합
+    for i in range(K):
+        sum_list[i + 1] = sum_list[i] + files[i]
+    
+    for i in range(1, K):
+        for j in range(i, K):
+            dp[j - i][j] = float('inf')
+            for k in range(j - i, j):
+                dp[j - i][j] = min(dp[j - i][j], dp[j - i][k] + dp[k + 1][j])
+            dp[j - i][j] += sum_list[j + 1] - sum_list[j - i]
+    
+    print(dp[0][K - 1])
+```
\ No newline at end of file
diff --git a/_posts/2025-01-19-trouble-shooting-momoso.markdown b/_posts/2025-01-19-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..586fda21b83
--- /dev/null
+++ b/_posts/2025-01-19-trouble-shooting-momoso.markdown
@@ -0,0 +1,54 @@
+---
+title: "[Troubleshooting] docker 빌드 시 권한 문제로 install이 안되는 문제"
+author: kwon
+date: 2025-01-19T23:00:00 +0900
+categories: [toubleshooting]
+tags: [docker, npm]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+`docker-compose build`로 빌드를 진행할 때 아래와 같은 문제가 발생
+
+```bash
+[+] Building 14.0s (14/19)                             docker:desktop-linux
+...
+ => ERROR [frontend internal] load build context                      12.7s 
+ ...
+ => CANCELED [api 4/6] RUN pip install --no-cache-dir -r requirement  12.5s
+------
+ > [frontend internal] load build context:
+------
+failed to solve: archive/tar: unknown file mode ?rwxr-xr-x
+```
+---
+
+# 💡원인
+
+```bash
+failed to solve: archive/tar: unknown file mode ?rwxr-xr-x
+```
+
+- 위 메세지에서 권한 관련 문제라는 것을 추측하였고, `frontend internal` 에서 발생한 문제이므로 frontend contianer의 문제라고 생각하여 이에 대해 비슷한 문제가 있는 경우를 탐색
+- 자료가 많이 있지는 않았지만 `.dockerignore` 에서 `node_modules`를 추가하고 정상적으로 빌드가 가능했다는 사례에 착안하여 `node_modules` 내부의 파일을 함께 이미지로 build 하려고 했을 때 권한 문제가 있다고 판단.
+---
+
+# 🛠 해결책
+
+- 첫 시도는 `docker-compose build --no-cache` 명령어를 통해 기존의 cache를 모두 날리고 `.dockerignore`에 `node_modules`를 추가한 뒤 다시 빌드를 진행
+    - 하지만 똑같은 문제가 발생하였음
+- 두 번째 시도로 `node_modules`와 `package-lock.json`를 삭제하고 처음 시도했던 방식으로 빌드를 진행
+    - 이 경우 정상적으로 빌드가 진행되었음
+---
+
+# 🤔 회고
+
+- 새로운 npm 환경을 가지고 왔을 때는 `node_modules`와 `package-lock.json` 를 삭제하고 다시 설치해보는 시도를 해봐야겠다.
+- 다른 곳에서 가지고 온 module 파일과 같은 환경 파일의 권한이 잘못 설정되어 있을 수 있다.
+
+---
+# 📚 Reference
+
+- [https://github.com/docker/for-win/issues/14083](https://github.com/docker/for-win/issues/14083)
\ No newline at end of file
diff --git a/_posts/2025-01-20-trouble-shooting-momoso.markdown b/_posts/2025-01-20-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..9da0ec92d23
--- /dev/null
+++ b/_posts/2025-01-20-trouble-shooting-momoso.markdown
@@ -0,0 +1,39 @@
+---
+title: "[Troubleshooting] gitlab-runner 상에서 docker 빌드가 안되는 문제"
+author: kwon
+date: 2025-01-20T23:00:00 +0900
+categories: [toubleshooting]
+tags: [docker, gitlab-ci-cd]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- `gitlab-runner` 이미지로 docker 빌드를 하려 할 때 아래와 같은 문제 발생
+
+    ```bash
+    Status: Downloaded newer image for gitlab/gitlab-runner:alpine
+    docker: Error response from daemon: manifest has incorrect mediatype: application/vnd.oci.image.index.v1+json.
+    See 'docker run --help'.
+    ```
+---
+
+# 💡원인
+
+- image와 현재 환경이 맞지 않는 것으로 판단
+---
+
+# 🛠 해결책
+
+- 버전을 v14으로 낮춰서 빌드를 진행하였고, 성공함
+---
+
+# 🤔 회고
+
+- 자료들을 찾아본 결과 mediatype문제는 거의 최신 버전을 제대로 지원하지 못해 생기는 문제인 것 같다. 버전을 바꿔서 시도해보자.
+
+---
+# 📚 Reference
+
+- [https://github.com/docker/for-win/issues/14083](https://stackoverflow.com/questions/59092140/docker-push-fails-manifest-invalid)
\ No newline at end of file
diff --git a/_posts/2025-01-21-trouble-shooting-momoso-2.markdown b/_posts/2025-01-21-trouble-shooting-momoso-2.markdown
new file mode 100644
index 00000000000..43ce6066ab6
--- /dev/null
+++ b/_posts/2025-01-21-trouble-shooting-momoso-2.markdown
@@ -0,0 +1,101 @@
+---
+title: "gitlab-runner container에서 Command not found가 발생하는 문제"
+author: kwon
+date: 2025-01-21T23:00:00 +0900
+categories: [toubleshooting]
+tags: [gitlab-ci-cd, docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- gitlab runner 이미지로 만든 컨테이너에서 `sh`, `bash`, `tail`과 같은 명령어를 사용하려고 할 때 아래와 같은 문제 발생
+    
+    ```bash
+    gitlab_runner   | Runtime platform                                    arch=amd64 os=linux pid=7 revision=782c6ecb version=16.9.1
+    gitlab_runner   | FATAL: Command tail not found.  
+    ```
+    
+---
+
+# 💡원인
+
+- ~~왜 됨…?~~
+
+이 문제는 GitLab Runner 컨테이너가 실행될 때 `entrypoint` 스크립트에 의해 예상치 못한 명령어(`tail` 등)가 실행되면서 발생한 오류입니다. 이를 해결하기 위해 `entrypoint: [""]`를 추가하면, 컨테이너의 기본 엔트리포인트 동작이 비활성화되고 직접 지정한 명령어만 실행됩니다.
+
+### 이유와 원리
+
+1. **기본 Entrypoint와 CMD**:
+    - Docker 이미지는 보통 `ENTRYPOINT`와 `CMD`를 지정할 수 있습니다.
+    - `ENTRYPOINT`는 컨테이너가 실행될 때 무조건 실행되는 스크립트나 명령어를 정의합니다.
+    - `CMD`는 `ENTRYPOINT`와 함께 전달될 추가 인자를 정의하거나, `ENTRYPOINT`가 없을 경우 기본 명령어로 사용됩니다.
+2. **문제의 원인**:
+    - GitLab Runner의 Docker 이미지는 `ENTRYPOINT`로 기본 동작이 정의되어 있습니다. 특정 상황에서는 이 `ENTRYPOINT` 스크립트가 `tail` 명령어를 사용하거나 잘못된 실행 환경을 유발할 수 있습니다.
+    - `tail not found`라는 오류는 컨테이너 내부에서 `tail` 명령어를 실행하려 했지만, `tail`이 설치되어 있지 않거나 경로 설정이 올바르지 않은 경우 발생합니다.
+3. **`entrypoint: [""]`의 효과**:
+    - `entrypoint: [""]`를 추가하면 Docker Compose는 기본 이미지를 사용할 때 지정된 `ENTRYPOINT`를 비활성화합니다.
+    - 이로 인해 컨테이너가 실행될 때 `CMD` 또는 `command`에서 지정한 명령만 실행됩니다.
+
+### 해결 방법의 작동 방식
+
+- 기본 `ENTRYPOINT`를 비활성화하면 GitLab Runner 컨테이너가 의존하는 스크립트나 명령이 실행되지 않으므로, 사용자가 명시적으로 지정한 명령만 실행되어 오류를 피할 수 있습니다.
+
+### 주의점
+
+1. `entrypoint: [""]`로 `ENTRYPOINT`를 비활성화했을 때, 컨테이너의 의도된 기본 동작이 실행되지 않을 수 있습니다. 따라서 명령어(`command` 또는 `CMD`를 통해})를 명확히 지정해야 합니다.
+
+---
+
+
+# 🛠 해결책
+
+- docker-comspose에 `entrypoint: [""]` 를 추가하여 해결
+    
+    ```yaml
+    # docker-compsoe.yml
+    ...
+      gitlab-runner:
+        image: gitlab/gitlab-runner:v16.9.1
+        container_name: gitlab_runner
+        restart: unless-stopped
+        volumes:
+          - ./gitlab-runner/config:/etc/gitlab-runner
+          - /var/run/docker.sock:/var/run/docker.sock
+        environment:
+          - TZ=Asia/Seoul
+          - CI_SERVER_URL=${CI_SERVER_URL}
+          - REGISTRATION_TOKEN=${REGISTRATION_TOKEN}
+          - RUNNER_EXECUTOR=${RUNNER_EXECUTOR}     # docker, shell 등
+        command: >
+          sh -c "
+            gitlab-runner register
+              --non-interactive
+              --url $CI_SERVER_URL
+              --registration-token $REGISTRATION_TOKEN
+              --executor $RUNNER_EXECUTOR
+              --description 'my-docker-runner'
+              --tag-list 'docker,fastapi'
+              --run-untagged='true'
+              --locked='false'
+              --access-level='not_protected'
+            && gitlab-runner run --working-directory=/home/gitlab-runner
+          " 
+        entrypoint: [""]
+        networks:
+          - default
+    ...
+    ```
+---
+
+# 🤔 회고
+
+- 단지 gtilab-ci에 대한 이해가 부족해서 생긴 문제
+
+---
+# 📚 Reference
+
+- [https://stackoverflow.com/questions/48945972/gitlab-runner-locally-no-such-command-sh](https://stackoverflow.com/questions/48945972/gitlab-runner-locally-no-such-command-sh)
+
+- [https://docs.gitlab.com/ee/ci/docker/using_docker_images.html#overriding-the-entrypoint-of-an-image](https://docs.gitlab.com/ee/ci/docker/using_docker_images.html#overriding-the-entrypoint-of-an-image)
\ No newline at end of file
diff --git a/_posts/2025-01-21-trouble-shooting-momoso.markdown b/_posts/2025-01-21-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..65fa3a104c4
--- /dev/null
+++ b/_posts/2025-01-21-trouble-shooting-momoso.markdown
@@ -0,0 +1,185 @@
+---
+title: "[Troubleshooting] gitlab-runner에서 panic: EOF [recovered]가 발생하는 문제"
+author: kwon
+date: 2025-01-21T23:00:00 +0900
+categories: [toubleshooting]
+tags: [gitlab-ci-cd, docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- gitlab-ic의 컨테이너 내부에서 `gitlab-runner register`를 실행했을 때 다음과 같은 오류 발생
+
+    ```bash
+    gitlab_runner   | Runtime platform                                    arch=amd64 os=linux pid=7 revision=782c6ecb version=16.9.1
+    gitlab_runner   | Running in system-mode.                            
+    gitlab_runner   |                                                                                                                                   
+    gitlab_runner   | Enter the GitLab instance URL (for example, https://gitlab.com/):                                                                 
+    gitlab_runner   | [https://lab.ssafy.com]: panic: EOF [recovered]                                                                                   
+    gitlab_runner   |       panic: EOF   
+    ```
+---
+
+# 💡원인
+
+- GPT의 답변
+
+    이 문제는 GitLab Runner 컨테이너가 실행되는 동안 사용자 입력을 요구하지만, 컨테이너의 표준 입력(stdin)과 터미널 연결(tty)이 활성화되지 않아 발생합니다. 이를 해결하기 위해 `stdin_open: true`와 `tty: true`를 설정하면, 컨테이너가 인터랙티브 모드에서 실행되어 사용자 입력을 처리할 수 있게 됩니다.
+
+    ### 문제의 원인
+
+    1. **컨테이너의 입력 요구**:
+        - GitLab Runner는 실행 시 `gitlab-runner register` 명령어를 통해 GitLab 서버 URL 및 토큰과 같은 설정 값을 입력받아야 합니다.
+        - 기본적으로 Docker 컨테이너는 입력을 처리할 수 있는 터미널 환경을 제공하지 않으므로, 입력이 차단되거나 EOF(End of File) 상태로 간주되어 프로그램이 비정상 종료됩니다.
+    2. **`panic: EOF`의 의미**:
+        - 프로그램이 사용자 입력을 기다릴 때, EOF가 발생하면 입력 스트림이 끝났다는 신호를 받습니다.
+        - GitLab Runner는 입력이 종료된 상황을 처리하지 못해 `panic: EOF` 오류를 발생시킵니다.
+
+    ---
+
+    ### 해결 방법: `stdin_open: true`와 `tty: true`
+
+    1. **`stdin_open: true`**:
+        - Docker Compose에서 `stdin_open: true`를 설정하면 컨테이너의 표준 입력(stdin)을 열어줍니다.
+        - 이는 Docker의 `i` 옵션과 동일하며, 컨테이너가 표준 입력을 지속적으로 대기하도록 만듭니다.
+    2. **`tty: true`**:
+        - `tty: true`를 설정하면 컨테이너에 가상 터미널(tty)을 할당합니다.
+        - 이는 Docker의 `t` 옵션과 동일하며, 인터랙티브 세션에서 터미널처럼 동작하게 만듭니다.
+    3. **결합된 효과**:
+        - 이 두 옵션을 함께 사용하면 컨테이너가 입력을 받을 수 있는 터미널 환경을 갖추게 되어, GitLab Runner가 사용자 입력을 정상적으로 처리할 수 있습니다.
+        - 결과적으로 `panic: EOF` 오류가 발생하지 않고 필요한 설정 과정을 완료할 수 있습니다.
+
+    ---
+
+    ### 실행 원리
+
+    아래와 같이 Docker Compose 파일에 설정하면:
+
+    ```yaml
+    services:
+    gitlab_runner:
+        image: gitlab/gitlab-runner:latest
+        stdin_open: true
+        tty: true
+
+    ```
+
+    이 설정은 컨테이너가 시작될 때:
+
+    1. 표준 입력이 열려 있어 사용자 입력을 받을 준비가 됨.
+    2. 터미널 환경이 활성화되어 입력과 출력이 자연스럽게 연결됨.
+
+    ---
+
+    ### 대안 방법
+
+    만약 자동화된 방식으로 설정을 완료하고 싶다면, 다음 방법을 사용할 수 있습니다:
+
+    1. **사전 등록 설정**:
+        - 필요한 환경 변수를 `.gitlab-runner` 디렉토리나 환경 변수로 전달하여 수동 입력을 피할 수 있습니다.
+        - 예:
+            
+            ```yaml
+            environment:
+            - RUNNER_NAME=my-runner
+            - REGISTRATION_TOKEN=your-token
+            - CI_SERVER_URL=https://gitlab.example.com/
+            
+            ```
+            
+    2. **스크립트 사용**:
+        - `gitlab-runner register` 명령어를 스크립트로 작성하여 입력을 자동화할 수 있습니다.
+
+    이 방법을 사용하면 `stdin_open`과 `tty` 설정 없이도 자동으로 등록을 완료할 수 있습니다.
+---
+# 🛠 해결책
+
+- docker-compose를 다음과 같이 수정하여 해결
+    
+    ```yaml
+    # docker-compose
+    ...
+      gitlab-runner:
+        image: gitlab/gitlab-runner:v16.9.1
+        stdin_open: true # -i 옵션과 동일
+        tty: true        # -t 옵션과 동일
+        container_name: gitlab_runner
+        restart: unless-stopped
+    ...
+    ```
+    
+    이 경우 사용자의 입력을 받아야 하는 상황에서 입력을 정상적으로 받지 못해 `panic: EOF` 오류가 발생한 것.
+    
+    `docker run`의 `-it` 옵션을 통해 표준 입력과 가상 터미널을 할당하는 것으로 오류를 피할 수 있지만 이 경우 입력을 받아야 하기 때문에 명령이 다음 상황에서 더 진행되지 않음
+    
+    ```bash
+    2025-01-21 10:46:08 Runtime platform                                    arch=amd64 os=linux pid=7 revision=782c6ecb version=16.9.1
+    2025-01-21 10:46:08 Running in system-mode.                            
+    2025-01-21 10:46:08                                                    
+    2025-01-21 10:46:08 Enter the GitLab instance URL (for example, https://gitlab.com/):
+    ```
+    
+    바로 입력을 반영할 수 있는 방법이 필요
+    
+- 입력을 받지 않을 것이므로 `-it` 옵션을 지우고 `entrypoint.sh`를 다음과 같이 구성하여 환경 변수를 통해 실행되도록 함
+    
+    ```bash
+    #!/bin/bash
+    set -e
+    
+    if [ ! -f /etc/gitlab-runner/config.toml ]; then
+      echo "Registering GitLab Runner..."
+      gitlab-runner register \
+        --non-interactive \
+        --url "$CI_SERVER_URL" \
+        --registration-token "$REGISTRATION_TOKEN" \
+        --executor "$RUNNER_EXECUTOR" \
+        --docker-image "alpine:latest" \
+        --description "$RUNNER_NAME" \
+        --tag-list "docker,fastapi" \
+        --run-untagged="true" \
+        --locked="false" \
+        --access-level="not_protected"
+    fi
+    
+    echo "Starting GitLab Runner..."
+    gitlab-runner run --working-directory=/etc/gitlab-runner
+    
+    ```
+    
+    docker-compose는 다음과 같이 수정하여 entrypoint가 실행되도록 한다.
+    
+    ```yaml
+    ...
+      gitlab-runner:
+        image: gitlab/gitlab-runner:v16.9.1
+        container_name: gitlab_runner
+        restart: unless-stopped
+        volumes:
+          - ./gitlab-runner/config:/etc/gitlab-runner
+          - /var/run/docker.sock:/var/run/docker.sock
+        environment:
+          - RUNNER_NAME=my-runner
+          - TZ=Asia/Seoul
+          - CI_SERVER_URL=${CI_SERVER_URL}
+          - REGISTRATION_TOKEN=${REGISTRATION_TOKEN}
+          - RUNNER_EXECUTOR=${RUNNER_EXECUTOR}
+        entrypoint: ["/bin/bash", "/entrypoint.sh"]
+    ...
+    ```
+
+---
+
+# 🤔 회고
+
+- 만약 `panic: EOF` 오류가 발생한다면 `-it` 옵션으로 입력을 받도록 할 수 있다.
+- 하지만 이번에 발생한 본질적인 문제는 환경변수가 제대로 들어가지 않아 발생한 것.
+    - 표면적인 메세지에 집중하지 말고 더 깊이 있는 본질적인 문제를 아는 것이 중요.
+- 동작해야 하는 명령이 많은 경우 `entrypoint.sh` 를 작성하여 관리하는 것이 관리 측면이나 디버깅 측면에서 좋을 것 같음
+
+---
+# 📚 Reference
+
+- [https://gitlab.com/gitlab-org/gitlab-runner/-/issues/29078](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/29078)
\ No newline at end of file
diff --git a/_posts/2025-01-22-trouble-shooting-momoso.markdown b/_posts/2025-01-22-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..4b6bd7aa65e
--- /dev/null
+++ b/_posts/2025-01-22-trouble-shooting-momoso.markdown
@@ -0,0 +1,175 @@
+---
+title: "[Troubleshooting] gitlab-runner가 연결하려 할 때 403 error"
+author: kwon
+date: 2025-01-22T23:00:00 +0900
+categories: [toubleshooting]
+tags: [gitlab-ci-cd, docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+### 명령어
+
+```bash
+gitlab-runner register \
+  --non-interactive \
+  --url "$CI_SERVER_URL" \
+  --registration-token "$REGISTRATION_TOKEN" \
+  --executor "$RUNNER_EXECUTOR" \
+  --docker-image "alpine:latest" \
+  --description "$RUNNER_NAME" \
+  --tag-list "docker,fastapi" \
+  --run-untagged="true" \
+  --locked="false" \
+  --access-level="not_protected"
+```
+
+### 오류
+
+```bash
+025-01-21 16:46:56 ERROR: Checking for jobs... forbidden               runner=t3_TgbhXF status=POST https://lab.ssafy.com/api/v4/jobs/request: 403 Forbidden
+2025-01-21 16:46:59 ERROR: Checking for jobs... forbidden               runner=t3_TgbhXF status=POST https://lab.ssafy.com/api/v4/jobs/request: 403 Forbidden
+2025-01-21 16:47:02 ERROR: Checking for jobs... forbidden               runner=t3_TgbhXF status=POST https://lab.ssafy.com/api/v4/jobs/request: 403 Forbidden
+2025-01-21 16:47:02 ERROR: Runner "https://lab.ssafy.comt3_TgbhXF" is unhealthy and will be disabled for 1h0m0s seconds!  unhealthy_requests=3 unhealthy_requests_limit=3
+```
+---
+
+
+# 💡원인
+
+- ~~매개변수의 역할을 제대로 확인하지 않아 발생한 문제~~
+    - ~~`--token`을 사용하면 이미 발급된 인증 토큰으로 바로 GitLab 서버와 통신하기 때문에 **403 Forbidden** 오류가 발생하지 않음.~~
+    - ~~`--registration-token`을 사용하려면 등록 후 인증 토큰이 올바르게 저장되었는지 확인해야 합니다.~~
+- ~~gitlab에서 발급한 토큰을 사용해 통신을 하기 위해서는 `--token` 을 사용해야 함~~
+- 기존에 등록했던 runner들이 남아 있고, 함께 run 되려 해서 생긴 문제인듯
+    
+    ```bash
+    / # gitlab-runner list
+    Runtime platform                                    arch=amd64 os=linux pid=52 revision=66a723c3 version=17.5.0
+    Listing configured runners                          ConfigFile=/etc/gitlab-runner/config.toml
+    my-runner                                           Executor=docker Token=glrt-t3_TgbhXFrg957wAC1GotYH URL=https://lab.ssafy.com
+    my-runner                                           Executor=shell Token=glrt-t3_iLs69W3NdhwWXSAPzd-j URL=https://lab.ssafy.com/
+    my-runner                                           Executor=shell Token=glrt-t3_iLs69W3NdhwWXSAPzd-j URL=https://lab.ssafy.com
+    ...
+    my-runner                                           Executor=shell Token=glrt-t3_AnQNmob79scgmUco33qb URL=https://lab.ssafy.com
+    my-runner                                           Executor=docker Token=glrt-t3_T4J5VMyULHjzsqBAXww5 URL=https://lab.ssafy.com/
+    my-runner                                           Executor=docker Token=glrt-t3_Nb98WV4oxRjNVcMxx9_J URL=https://lab.ssafy.com
+    ```
+---
+# 🛠 해결책
+
+- ~~명령어 변경~~
+    
+    ```bash
+    gitlab-runner register \
+      --url "$CI_SERVER_URL"\
+      --token "$REGISTRATION_TOKEN"\
+      --listen-address ":9252" \
+      --executor "docker"\
+      --docker-image "alpine:latest"
+    ```
+    
+- `config.toml`파일을 제거하고 다시 등록하니 403 발생 안됨
+
+---
+
+# 🤔 회고
+
+## 1. **`--registration-token`**
+
+### 역할
+
+- *Runner를 등록(Register)**할 때 사용되는 **일회성 토큰**입니다.
+- GitLab에서 새 Runner를 프로젝트, 그룹, 또는 인스턴스에 연결하기 위해 사용합니다.
+- 이 토큰은 Runner를 등록한 뒤에는 더 이상 사용되지 않습니다.
+
+### 발급 위치
+
+- **프로젝트**나 **그룹**의 **Settings > CI/CD > Runners** 섹션에서 확인 가능합니다.
+- 예: `Settings > CI/CD > Specific Runners`에서 `registration-token`으로 표시됩니다.
+
+### 주요 특징
+
+- **일회성 토큰**: Runner 등록에만 사용되며, 이후 Runner가 작업 요청을 할 때는 사용되지 않습니다.
+- Runner를 등록한 후 GitLab이 **`token`(인증 토큰)**을 발급합니다.
+
+---
+
+## 2. **`--token`**
+
+### 역할
+
+- Runner가 GitLab 서버와 **지속적으로 통신**하기 위한 **인증 토큰**입니다.
+- 작업(Job)을 요청하거나 실행 결과를 보고할 때 사용됩니다.
+- 등록 과정에서 자동으로 발급되며, Runner의 `config.toml` 파일에 저장됩니다.
+
+### 저장 위치
+
+- `config.toml` 파일에 저장됩니다:
+    
+    ```toml
+    [[runners]]
+      name = "my-runner"
+      url = "https://gitlab.example.com/"
+      token = "authentication-token"  # 인증 토큰
+      executor = "docker"
+    ```
+    
+
+### 주요 특징
+
+- **지속적으로 사용**: Runner가 GitLab 서버와 통신하는 모든 과정에서 사용됩니다.
+- 만약 잘못된 값이 설정되면 **403 Forbidden** 오류가 발생합니다.
+- GitLab UI에서는 보이지 않습니다. 대신 Runner가 등록된 후 자동으로 발급됩니다.
+
+---
+
+## 차이점 요약
+
+| 구분 | `--registration-token` | `--token` |
+| --- | --- | --- |
+| **역할** | Runner를 등록하기 위한 토큰 | Runner와 GitLab 서버 간 인증용 |
+| **발급 위치** | 프로젝트/그룹의 Runner 설정 | 등록 시 자동 생성 |
+| **사용 시점** | Runner 등록 시 한 번 사용 | 등록 후 지속적으로 사용 |
+| **가시성** | GitLab UI에서 확인 가능 | `config.toml`에 저장됨 |
+| **만료 여부** | 필요시 GitLab UI에서 재발급 가능 | 등록 시 자동으로 새로 생성됨 |
+
+---
+
+## 실질적인 사용 예시
+
+### 1. Runner를 등록할 때:
+
+```toml
+gitlab-runner register \
+  --url "https://gitlab.example.com/" \
+  --registration-token "registration-token" \
+  --executor "docker" \
+  --description "my-runner"
+```
+
+- 이 명령어로 GitLab 서버에 Runner를 등록합니다.
+- 등록 과정에서 GitLab이 인증 토큰(`-token`)을 생성하여 `config.toml`에 저장합니다.
+
+---
+
+### 2. Runner 실행:
+
+```bash
+gitlab-runner run
+```
+
+- 이 명령어는 `config.toml`에 저장된 인증 토큰(`-token`)을 사용해 GitLab 서버와 통신합니다.
+- `-registration-token`은 이 단계에서 더 이상 사용되지 않습니다.
+
+---
+
+## 결론
+
+- *`-registration-token`*은 Runner를 GitLab 서버에 **등록**하기 위한 초기 설정 토큰입니다.
+- *`-token`*은 등록 후 **GitLab과의 지속적인 인증**을 위해 사용됩니다.
+- `403 Forbidden` 문제가 발생한다면, 대개 `config.toml`에 저장된 **`token`** 값이 잘못되었거나 유효하지 않기 때문입니다.
+---
+# 📚 Reference
\ No newline at end of file
diff --git a/_posts/2025-01-23-trouble-shooting-momoso.markdown b/_posts/2025-01-23-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..f4a87db0a2c
--- /dev/null
+++ b/_posts/2025-01-23-trouble-shooting-momoso.markdown
@@ -0,0 +1,89 @@
+---
+title: "[Troubleshooting] docker 안에서 gitlab-runner exec가 작동하지 않는 문제"
+author: kwon
+date: 2025-01-23T23:00:00 +0900
+categories: [toubleshooting]
+tags: [gitlab-ci-cd, docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+```bash
+/ # gitlab-runner exec shell build
+Runtime platform                                    arch=amd64 os=linux pid=139 revision=66a723c3 version=17.5.0
+FATAL: Command exec not found.
+```
+---
+
+
+# 💡원인
+
+- gitlab-runner의 버전이 `v17`  이상인 경우 exec가 안되는 경우가 있다고 한다.
+
+---
+
+
+# 🛠 해결책
+- gitlab-runner의 버전을 `v16.10.0`으로 내렸다.
+    
+    ```yaml
+    services:
+      gitlab-runner:
+        image: gitlab/gitlab-runner:v16.10.0
+        container_name: gitlab_runner
+        restart: always
+        volumes:
+          - ./gitlab-runner/config:/etc/gitlab-runner
+          - /var/run/docker.sock:/var/run/docker.sock
+          - ./entrypoint.sh:/entrypoint.sh
+        environment:
+          - RUNNER_NAME=my-runner
+          - TZ=Asia/Seoul
+          - CI_SERVER_URL=${CI_SERVER_URL}
+          - REGISTRATION_TOKEN=${REGISTRATION_TOKEN}
+          - RUNNER_EXECUTOR=${RUNNER_EXECUTOR}
+        ports:
+          - "9252:9252"
+        entrypoint: ["tail", "-f", "dev/null"]
+    ```
+    
+    아래와 같이 잘 작동하는 것을 확인
+    
+    ```bash
+    # gitlab-runner exec
+    Runtime platform                                    arch=amd64 os=linux pid=13 revision=81ab07f6 version=16.10.0
+    NAME:
+       gitlab-runner exec - execute a build locally
+    
+    USAGE:
+       gitlab-runner exec command [command options] [arguments...]
+    
+    COMMANDS:
+       virtualbox      use virtualbox executor
+       docker-windows  use docker-windows executor
+       docker+machine  use docker+machine executor
+       custom          use custom executor
+       parallels       use parallels executor
+       docker          use docker executor
+       kubernetes      use kubernetes executor
+       shell           use shell executor
+       ssh             use ssh executor
+    
+    OPTIONS:
+       --help, -h  show help
+    ```
+
+---
+
+
+# 🤔 회고
+
+- 버전 억까가 있을 경우 gpt가 잘 해결하지 못한다. 버전 문제가 의심된다면 구글링을 통해 비슷한 경우가 있는지 살펴보자.
+
+---
+
+
+# 📚 Reference
+- [https://gitlab.com/gitlab-org/gitlab-runner/-/issues/37523](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/37523)
\ No newline at end of file
diff --git a/_posts/2025-01-31-trouble-shooting-momoso.markdown b/_posts/2025-01-31-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..d6238b72ac0
--- /dev/null
+++ b/_posts/2025-01-31-trouble-shooting-momoso.markdown
@@ -0,0 +1,58 @@
+---
+title: "[Troubleshooting] pem 키로 ssh 접근 시 권한 문제가 발생하는 경우"
+author: kwon
+date: 2025-01-31T23:00:00 +0900
+categories: [toubleshooting]
+tags: [ssh, AWS]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- pem키를 사용하여 ssh 접근 시 다음과 같이 에러가 발생
+    
+    ```bash
+    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+    @         WARNING: UNPROTECTED PRIVATE KEY FILE!          @
+    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+    Permissions 0644 for 'amazonec2.pem' are too open.
+    It is recommended that your private key files are NOT accessible by others.
+    This private key will be ignored.
+    bad permissions: ignore key: amazonec2.pem
+    Permission denied (publickey).
+    ```
+---
+
+
+# 💡원인
+
+- pem 파일에 너무 많은 권한이 부여되어 보안 상 AWS에서 거부한 것
+---
+
+
+# 🛠 해결책
+
+- 읽기만 가능하도록 접근 권한을 바꿔줘야 한다.
+    
+    ```bash
+    # unix 기반
+    chmod 400 key.pem
+    
+    # windows
+    icacls.exe key.pem /reset
+    icacls.exe key.pem /grant:r %username%:(R)
+    icacls.exe key.pem /inheritance:r
+    ```
+---
+
+
+# 🤔 회고
+
+- 키를 저장하고 있는 파일의 권한에 따라 접근이 거부될 줄은 몰랐다. 생각해보니 너무 많은 권한이 키에 있을 경우 상당히 위험할 수 있겠다는 생각이 들어 수긍하였다.
+---
+
+
+# 📚 Reference
+
+- [https://dabid.tistory.com/11](https://dabid.tistory.com/11)
\ No newline at end of file
diff --git a/_posts/2025-02-03-trouble-shooting-momoso.markdown b/_posts/2025-02-03-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..c315990e50f
--- /dev/null
+++ b/_posts/2025-02-03-trouble-shooting-momoso.markdown
@@ -0,0 +1,86 @@
+---
+title: "[Troubleshooting] docker에서 react-scripts를 찾지 못하는 문제"
+author: kwon
+date: 2025-02-03T23:00:00 +0900
+categories: [toubleshooting]
+tags: [docker, react]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+- docker-compose로 react 프로젝트를 실행하려 할 때 아래와 같은 문제 발생
+
+```bash
+react_frontend  | 
+react_frontend  | > app@1.0.0 start
+react_frontend  | > react-scripts start                                              
+react_frontend  |                                                                    
+react_frontend  | sh: react-scripts: not found                                       
+react_frontend exited with code 127
+```
+
+---
+
+
+# 💡원인
+
+- Dockerfile에 명시한 `npm install` 이 실행되지 않고 생략되는 것을 확인(`Cached`)
+- local의 node_modules가 container 내부에 영향을 주는 것으로 판단
+---
+
+
+# 🛠 해결책
+
+- `.dockerignore`에 node_modules를 추가
+    
+    ```
+    npm-debug.log
+    node_modules
+    build
+    Dockerfile
+    .git
+    *.log
+    *.env
+    *.tmp
+    *.bak
+    *.swp
+    *.DS_Store
+    ```
+    
+    - 효과는 없었음
+- docke-compose에 volume을 명시하여 node_modules가 contianer에서 독립적으로 관리될 수 있도록 수정
+    
+    ```yaml
+    ...
+      frontend:
+        build: ./Frontend
+        environment:
+          - CHOKIDAR_USEPOLLING=true  # 파일 변경 감지를 위한 설정
+        ports:
+          - "3000:3000"
+        volumes:
+          - ./Frontend:/app  # 로컬 파일 시스템을 컨테이너에 마운트
+          - /app/node_modules  # 로컬의 node_modules가 container 내에 적용되지 않도록
+        networks:
+          - app_network
+    ...
+    ```
+---
+
+
+# 🤔 회고
+
+- 해결하기 까지 정말 오래 걸렸다. node_modules를 지우고 하더라고 한 번만 잘 되고 계속 안됐었는데 mount된 volume에 local 파일이 영향을 줘서 생기는 문제라고는 생각을 못했다.
+- 어찌 보면 기본적인 compose 작성법일 수 있는데 기초 공부가 조금 부족하지 않았나 반성하게 되는 계기가 되었다.
+---
+
+
+# 📚 Reference
+
+- From GPT
+    
+    ### **`/app/node_modules`**
+    
+    - `node_modules` 폴더를 컨테이너 내에서 별도로 관리하여, 로컬의 `node_modules`과 충돌하는 것을 방지합니다.
+    - 이 설정이 없으면 `./Frontend/node_modules`가 컨테이너 내부 `/app/node_modules`로 덮어씌워져서, **컨테이너 내에서 설치된 패키지가 정상적으로 작동하지 않는 문제**가 발생할 수 있습니다.
\ No newline at end of file
diff --git a/_posts/2025-02-05-trouble-shooting-momoso.markdown b/_posts/2025-02-05-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..5c7ec7a83c5
--- /dev/null
+++ b/_posts/2025-02-05-trouble-shooting-momoso.markdown
@@ -0,0 +1,73 @@
+---
+title: "[Troubleshooting] gitlab-runner가 연결하려 할 때 403 error"
+author: kwon
+date: 2025-02-05T23:00:00 +0900
+categories: [toubleshooting]
+tags: [gitlab-ci-cd, docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- docker container 상에서 `npm install`을 했을 때 의존성 충돌 문제 발생
+    
+    ```bash
+     > [frontend 4/5] RUN npm install:
+    11.95 npm error code ERESOLVE
+    11.95 npm error ERESOLVE unable to resolve dependency tree
+    11.95 npm error
+    11.95 npm error While resolving: ssafy-vue@0.1.0
+    11.95 npm error Found: webpack@4.47.0
+    11.95 npm error node_modules/webpack
+    11.95 npm error   dev webpack@"^4.46.0" from the root project
+    11.95 npm error
+    11.95 npm error Could not resolve dependency:
+    11.95 npm error peer webpack@"5.x.x" from webpack-cli@5.1.4
+    11.95 npm error node_modules/webpack-cli
+    11.95 npm error   dev webpack-cli@"^5.1.4" from the root project
+    11.95 npm error
+    11.95 npm error Fix the upstream dependency conflict, or retry
+    11.95 npm error this command with --force or --legacy-peer-deps
+    11.95 npm error to accept an incorrect (and potentially broken) dependency resolution.
+    11.95 npm error
+    11.95 npm error
+    11.95 npm error For a full report see:
+    11.95 npm error /root/.npm/_logs/2025-02-04T16_58_55_692Z-eresolve-report.txt
+    11.96 npm notice
+    11.96 npm notice New major version of npm available! 10.8.2 -> 11.1.0
+    11.96 npm notice Changelog: https://github.com/npm/cli/releases/tag/v11.1.0
+    11.96 npm notice To update run: npm install -g npm@11.1.0
+    11.96 npm notice
+    11.96 npm error A complete log of this run can be found in: /root/.npm/_logs/2025-02-04T16_58_55_692Z-debug-0.log
+    ------
+    failed to solve: process "/bin/sh -c npm install" did not complete successfully: exit code: 1
+    ```
+---
+
+
+# 💡원인
+
+- `webpack@4.47.0`과 `webpack-cli@5.1.4` 간의 의존성 충돌 문제이다. `webpack-cli@5.x.x`는 `webpack@5.x.x`를 필요로 하지만, 현재 프로젝트에서는 `webpack@4.47.0`이 사용되고 있기 때문.
+---
+
+
+# 🛠 해결책
+
+- 일단 webpack의 버전을 5로 올려줬다.
+    
+    ```bash
+    npm install webpack@5 --save-dev
+    ```
+    
+- 추후에 front 담당자와 확실히 정하면 될 거 같다.
+---
+
+
+# 🤔 회고
+
+
+---
+
+
+# 📚 Reference
\ No newline at end of file
diff --git a/_posts/2025-02-08-trouble-shooting-momoso.markdown b/_posts/2025-02-08-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..d67daeacfd3
--- /dev/null
+++ b/_posts/2025-02-08-trouble-shooting-momoso.markdown
@@ -0,0 +1,152 @@
+---
+title: "[Troubleshooting] SSL 발급 억까 탐방기"
+author: kwon
+date: 2025-02-08T23:00:00 +0900
+categories: [toubleshooting]
+tags: [ssl, docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+1. 처음부터 SSL 사용하는 conf로 nginx를 실행하려고 하니 안됨(당연한 것)
+    
+    ```bash
+    /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
+    /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
+    /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
+    10-listen-on-ipv6-by-default.sh: info: /etc/nginx/conf.d/default.conf is not a file or does not exist
+    /docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
+    /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
+    /docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
+    /docker-entrypoint.sh: Configuration complete; ready for start up
+    2025/02/07 15:42:06 [emerg] 1#1: no "ssl_certificate" is defined for the "listen ... ssl" directive in /etc/nginx/conf.d/app.conf:14
+    nginx: [emerg] no "ssl_certificate" is defined for the "listen ... ssl" directive in /etc/nginx/conf.d/app.conf:14
+    ```
+    
+2. 인증서 발급을 위한 경로에 접근이 불가능
+    
+    ```bash
+    Saving debug log to /var/log/letsencrypt/letsencrypt.log
+    Requesting a certificate for momoso106.duckdns.org
+    
+    Certbot failed to authenticate some domains (authenticator: webroot). The Certificate Authority reported these problems:
+      Domain: momoso106.duckdns.org
+      Type:   connection
+      Detail: 43.202.64.156: Fetching http://momoso106.duckdns.org/.well-known/acme-challenge/0l6GR-2vhm72SJgBTBK83sLAUCt3sMbVqx-nPwfwRrk: Connection refused
+    
+    Hint: The Certificate Authority failed to download the temporary challenge files created by Certbot. Ensure that the listed domains serve their content from the provided --webroot-path/-w and that files created there can be downloaded from the internet.
+    
+    Some challenges have failed.
+    Ask for help or search for solutions at https://community.letsencrypt.org. See the logfile /var/log/letsencrypt/letsencrypt.log or re-run Certbot with -v for more details.
+    ```
+---
+
+
+# 💡원인
+
+1. `app.conf`가 SSL을 발급 받기 전에 SSL을 사용하려 하고 있음
+    
+    ```yaml
+    server {
+        listen 80;
+        server_name momoso106.duckdns.org;
+    
+        location /.well-known/acme-challenge/ {
+            root /var/www/certbot;
+        }
+    
+        location / {
+            return 301 https://$host$request_uri;
+        }
+    }
+    
+    server {
+        listen 443 ssl; // 이게 문제임
+        server_name momoso106.duckdns.org;
+    
+        location / {
+            root /app/frontend/build;
+            index index.html;
+            try_files $uri /index.html;
+        }
+    
+        location /api/ {
+            proxy_pass http://backend:8000/;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto https;
+        }
+    
+        location /openvidu/ {
+            proxy_pass https://openvidu:4443/;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto https;
+            proxy_ssl_verify off;
+        }
+    }
+    
+    ```
+
+2. directory 직접 만들어보기도 하고 별 짓 다 했는데, 결국 nginx가 1번 이유 때문에 계속 꺼져서 생기던 문제였음
+
+---
+
+
+# 🛠 해결책
+
+1. `listen 443 ssl`을 지우고 먼저 ssl 인증서를 발급
+    
+    ```yaml
+    server {
+        listen 80;
+        server_name momoso106.duckdns.org;
+    
+        location /.well-known/acme-challenge/ {
+            root /var/www/certbot;
+        }
+    
+        location / {
+            return 301 https://$host$request_uri;
+        }
+    	}
+    ```
+    
+    발급 성공
+    
+    ```bash
+    $ docker run --rm -v $(pwd)/certbot/www:/var/www/certbot -v $(pwd)/certbot/conf:/etc/letsencrypt certbot/certbot certonly --webroot -w /var/www/certbot -d momoso106.duckdns.org --email qja1998@naver.com --agree-tos --no-eff-email
+    Saving debug log to /var/log/letsencrypt/letsencrypt.log
+    Requesting a certificate for momoso106.duckdns.org
+    
+    Successfully received certificate.
+    Certificate is saved at: /etc/letsencrypt/live/momoso106.duckdns.org/fullchain.pem
+    Key is saved at:         /etc/letsencrypt/live/momoso106.duckdns.org/privkey.pem
+    This certificate expires on 2025-05-08.
+    These files will be updated when the certificate renews.
+    NEXT STEPS:
+    - The certificate will need to be renewed before it expires. Certbot can automatically renew the certificate in the background, but you may need to take steps to enable that functionality. See https://certbot.org/renewal-setup for instructions.
+    
+    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    If you like Certbot, please consider supporting our work by:
+     * Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
+     * Donating to EFF:                    https://eff.org/donate-le
+    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    ```
+---
+
+
+# 🤔 회고
+
+- 오랜만에 느껴보는 역대급 억까
+- 천천히 이유를 파악해보자
+---
+
+
+# 📚 Reference
+
+- [https://chatgpt.com/share/67a63056-27e4-8013-8566-54ad57ac11ad](https://chatgpt.com/share/67a63056-27e4-8013-8566-54ad57ac11ad)
\ No newline at end of file
diff --git a/_posts/2025-02-12-trouble-shooting-momoso.markdown b/_posts/2025-02-12-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..787175365c5
--- /dev/null
+++ b/_posts/2025-02-12-trouble-shooting-momoso.markdown
@@ -0,0 +1,44 @@
+---
+title: "[Troubleshooting] conda 가상환경 상에서 pip install로 설치한 모듈을 찾을 수 없는 경우"
+author: kwon
+date: 2025-02-12T23:00:00 +0900
+categories: [toubleshooting]
+tags: [python, conda]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- 분명 `conda activate` 이후 가상환경 안에서 `pip install`을 통해 모듈을 설치했음에도 불구하고 `not found module`이 발생하는 경우가 있다.
+---
+
+
+# 💡원인
+
+- pip의 경로를 확인해보면 conda 환경의 경로가 아님을 확인할 수 있다. 이 때문에 global 환경에 설치가 되어 가상환경 내에서 사용할 수 없었던 것
+    
+    ```bash
+    $ which pip
+    /home/user/.local/bin/pip
+    ```
+---
+
+
+# 🛠 해결책
+
+- pip를 현재 가상환경의 것으로 사용하도록 명시한다.
+    
+    ```bash
+    python -m pip install <module_name>
+    ```
+---
+
+
+# 🤔 회고
+
+
+---
+
+
+# 📚 Reference
\ No newline at end of file
diff --git a/_posts/2025-02-15-trouble-shooting-momoso.markdown b/_posts/2025-02-15-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..b5aa29ef1e8
--- /dev/null
+++ b/_posts/2025-02-15-trouble-shooting-momoso.markdown
@@ -0,0 +1,99 @@
+---
+title: "[Troubleshooting] gitlab ci 상에서 permission denied가 발생하는 문제"
+author: kwon
+date: 2025-02-15T23:00:00 +0900
+categories: [toubleshooting]
+tags: [gitlab-ci-cd]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+```bash
+permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock:
+Post "": dial unix /var/run/docker.sock: connect: permission denied
+```
+---
+
+
+# 💡원인
+
+- `.gitlab-ci.yml`을 다음과 같이 작성했다
+    
+    ```yaml
+    ...
+    build_backend:
+      tags:
+        - backend-runner
+      script:
+        - cd Backend
+        - docker build -t $IMAGE_BACKEND:$TAG -f Dockerfile.dev .
+        - docker push $IMAGE_BACKEND:$TAG
+      only:
+        - develop
+        - master
+    
+    build_frontend:
+      tags:
+        - frontend-runner
+      script:
+        - cd Frontend
+        - docker build -t $IMAGE_FRONTEND:$TAG -f Dockerfile.dev .
+        - docker push $IMAGE_FRONTEND:$TAG
+      only:
+        - develop
+        - master
+    ...
+    ```
+    
+    - 이런 식으로 작성할 경우 문법 상으로는 문제가 없지만 실제 commit 후 pipeline이 작동할 때 runner 때문에 문제가 발생한다.
+        - 두 job은 runner를 구분하지 않았기 때문에 자연스럽게 한 runner를 통해 build를 진행하려고 하는데 이 때 먼저 runner를 선점하지 못한 job은 docker daemon에 대한 권한을 얻을 수 없게 된다.
+        - 즉, docker를 사용하는 job이 같은 stage에서 작동한다면 runner를 분리해줘야 한다는 것
+---
+
+
+# 🛠 해결책
+
+```yaml
+...
+build_backend:
+  stage: build
+  tags:
+    - backend-runner
+  script:
+    - cd Backend
+    - docker build -t $IMAGE_BACKEND:$TAG -f Dockerfile.dev .
+    - docker push $IMAGE_BACKEND:$TAG
+  only:
+    - develop
+    - master
+
+build_frontend:
+  stage: build
+  tags:
+    - frontend-runner
+  script:
+    - cd Frontend
+    - docker build -t $IMAGE_FRONTEND:$TAG -f Dockerfile.dev .
+    - docker push $IMAGE_FRONTEND:$TAG
+  only:
+    - develop
+    - master
+...
+```
+
+- 이처럼 `tags`를 활용하여 해당 tag에 맞는 runner를 골라 사용할 수 있다.
+    - 지정한 tag를 가지는 runner는 생성해줘야 한다.
+---
+
+
+# 🤔 회고
+
+- 😡진짜 화가 잔뜩 났던 오류였고, 해결까지 정말 오래 걸렸다. 애먼 `.gitlab-ci.yml`만 계속해서 바꿔보고, dind도 적용해봤지만 오류는 계속 발생했다.
+- 그런 도중 backend만 성공하고 frontend는 빌드를 실패하는 것을 보고 docker를 중복으로 사용하려는 문제인가 하고 생각하게 되었다.
+- 진짜 오류는 겉만 보고는 모른다…
+---
+
+
+# 📚 Reference
\ No newline at end of file
diff --git a/_posts/2025-02-16-trouble-shooting-momoso-2.markdown b/_posts/2025-02-16-trouble-shooting-momoso-2.markdown
new file mode 100644
index 00000000000..d11268878c9
--- /dev/null
+++ b/_posts/2025-02-16-trouble-shooting-momoso-2.markdown
@@ -0,0 +1,55 @@
+---
+title: "[Troubleshooting] docker 상에서 redis가 정상적으로 연결되지 않는 문제"
+author: kwon
+date: 2025-02-16T23:00:00 +0900
+categories: [toubleshooting]
+tags: [docker, redis]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+```bash
+...
+dev-backend   |     connection.connect()
+dev-backend   |     ~~~~~~~~~~~~~~~~~~^^
+dev-backend   |   File "/usr/local/lib/python3.13/site-packages/redis/connection.py", line 363, in connect
+dev-backend   |     raise ConnectionError(self._error_message(e))
+dev-backend   | redis.exceptions.ConnectionError: Error 111 connecting to 127.0.0.1:6379. Connection refused.
+```
+---
+
+
+# 💡원인
+
+- redis가 docker에 제대로 연결되지 않아 발생하는 문제
+    - `127.0.0.1`은 local에서 사용하는 것이므로 docker에 맞게 바꿔줄 필요가 있음
+---
+
+
+# 🛠 해결책
+
+```yaml
+from redis import Redis
+from fastapi import HTTPException
+from twilio.rest import Client
+import random
+import os
+
+# Redis 설정
+redis_client = Redis(host=**"redis"**, port=6379, db=0, decode_responses=True)
+...
+```
+
+- host에 docker container의 이름이 들어가야 합니다.
+---
+
+
+# 🤔 회고
+
+
+---
+
+
+# 📚 Reference
\ No newline at end of file
diff --git a/_posts/2025-02-16-trouble-shooting-momoso.markdown b/_posts/2025-02-16-trouble-shooting-momoso.markdown
new file mode 100644
index 00000000000..17401b87fdc
--- /dev/null
+++ b/_posts/2025-02-16-trouble-shooting-momoso.markdown
@@ -0,0 +1,44 @@
+---
+title: "[Troubleshooting] docker에서 volume을 연결해도 파일이 보이지 않는 문제"
+author: kwon
+date: 2025-02-16T23:00:00 +0900
+categories: [toubleshooting]
+tags: [docker]
+math: true
+mermaid: false
+---
+
+# 🚫 현상
+
+- `npm run build`로 build 파일을 만들고 image를 만들었음에도 불구하고 mount한 local에 build 파일들이 나타나지 않았음
+---
+
+
+# 💡원인
+
+1. 기존에 이미지에 있는 파일들은 자동 반영 안됨
+    - 기존에 이미지에 있었던 build 파일들은 mount되어 있더라고 자동으로 반영되지 않는다.
+2. mount를 할 경우 local(source)의 상태가 덮어 씌워짐
+    - 이미지를 build 하는 도중에 확인한 log에서는 분명 node build 파일이 정상적으로 생성되었었다.
+    - compose를 통해 mount를 하고 실행했을 경우 build 파일이 모두 사라진 것을 확인할 수 있었는데 이건 local의 상태(비어있는 directory)가 덮어 씌워졌기 때문
+---
+
+
+# 🛠 해결책
+
+- `Dockerfile`에서 build 파일들을 복사하는 과정을 추가하였다.
+    
+    ```bash
+    ...
+    CMD ["cp", "-r", "/app/dist", "/app/frontend_build"]
+    ```
+---
+
+
+# 🤔 회고
+
+- volume mount를 할 때 local의 상태가 덮어 쓰기 된다는 것을 명심하자
+---
+
+
+# 📚 Reference
\ No newline at end of file
diff --git a/assets/img/avatar/avatar.jpg b/assets/img/avatar/avatar.jpg
new file mode 100644
index 00000000000..b8b3706fe07
Binary files /dev/null and b/assets/img/avatar/avatar.jpg differ
diff --git a/assets/img/favicons/android-chrome-192x192.png b/assets/img/favicons/android-chrome-192x192.png
index a949d2fe5d1..5ba5475797b 100644
Binary files a/assets/img/favicons/android-chrome-192x192.png and b/assets/img/favicons/android-chrome-192x192.png differ
diff --git a/assets/img/favicons/android-chrome-512x512.png b/assets/img/favicons/android-chrome-512x512.png
index a0cdd950b35..dbd340fd585 100644
Binary files a/assets/img/favicons/android-chrome-512x512.png and b/assets/img/favicons/android-chrome-512x512.png differ
diff --git a/assets/img/favicons/apple-touch-icon.png b/assets/img/favicons/apple-touch-icon.png
index 648097f4fc7..98b38dd6c17 100644
Binary files a/assets/img/favicons/apple-touch-icon.png and b/assets/img/favicons/apple-touch-icon.png differ
diff --git a/assets/img/favicons/favicon-16x16.png b/assets/img/favicons/favicon-16x16.png
index f44237a9a42..c2cc5836eb9 100644
Binary files a/assets/img/favicons/favicon-16x16.png and b/assets/img/favicons/favicon-16x16.png differ
diff --git a/assets/img/favicons/favicon-32x32.png b/assets/img/favicons/favicon-32x32.png
index d5d021d85c8..f1fa2333b9c 100644
Binary files a/assets/img/favicons/favicon-32x32.png and b/assets/img/favicons/favicon-32x32.png differ
diff --git a/assets/img/favicons/favicon.ico b/assets/img/favicons/favicon.ico
index 561156802e6..147e6a72c8d 100644
Binary files a/assets/img/favicons/favicon.ico and b/assets/img/favicons/favicon.ico differ
diff --git a/assets/img/favicons/site.webmanifest b/assets/img/favicons/site.webmanifest
index 03c6113b824..45dc8a20658 100644
--- a/assets/img/favicons/site.webmanifest
+++ b/assets/img/favicons/site.webmanifest
@@ -1,26 +1 @@
----
-layout: compress
----
-
-{% assign favicon_path = "/assets/img/favicons" | relative_url %}
-
-{
-  "name": "{{ site.title }}",
-  "short_name": "{{ site.title }}",
-  "description": "{{ site.description }}",
-  "icons": [
-    {
-      "src": "{{ favicon_path }}/android-chrome-192x192.png",
-      "sizes": "192x192",
-      "type": "image/png"
-    },
-    {
-      "src": "{{ favicon_path }}/android-chrome-512x512.png",
-      "sizes": "512x512",
-      "type": "image/png"
-    }],
-  "start_url": "{{ '/index.html' | relative_url }}",
-  "theme_color": "#2a1e6b",
-  "background_color": "#ffffff",
-  "display": "fullscreen"
-}
+{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}
\ No newline at end of file
diff --git a/assets/img/posting_imgs/autoencoder-loss.png b/assets/img/posting_imgs/autoencoder-loss.png
new file mode 100644
index 00000000000..13a2c03e52d
Binary files /dev/null and b/assets/img/posting_imgs/autoencoder-loss.png differ
diff --git a/assets/img/posting_imgs/autoencoder.png b/assets/img/posting_imgs/autoencoder.png
new file mode 100644
index 00000000000..f34dd4264e5
Binary files /dev/null and b/assets/img/posting_imgs/autoencoder.png differ
diff --git a/assets/img/posting_imgs/avatar.jpg b/assets/img/posting_imgs/avatar.jpg
new file mode 100644
index 00000000000..d831709cd42
Binary files /dev/null and b/assets/img/posting_imgs/avatar.jpg differ
diff --git a/assets/img/posting_imgs/backward.png b/assets/img/posting_imgs/backward.png
new file mode 100644
index 00000000000..96ae04a467c
Binary files /dev/null and b/assets/img/posting_imgs/backward.png differ
diff --git a/assets/img/posting_imgs/boj-1005.png b/assets/img/posting_imgs/boj-1005.png
new file mode 100644
index 00000000000..5fac6a694ba
Binary files /dev/null and b/assets/img/posting_imgs/boj-1005.png differ
diff --git a/assets/img/posting_imgs/boj_1074.jpg b/assets/img/posting_imgs/boj_1074.jpg
new file mode 100644
index 00000000000..6f05a437492
Binary files /dev/null and b/assets/img/posting_imgs/boj_1074.jpg differ
diff --git a/assets/img/posting_imgs/boj_11066.png b/assets/img/posting_imgs/boj_11066.png
new file mode 100644
index 00000000000..9cc57d29471
Binary files /dev/null and b/assets/img/posting_imgs/boj_11066.png differ
diff --git a/assets/img/posting_imgs/boj_1406-1.png b/assets/img/posting_imgs/boj_1406-1.png
new file mode 100644
index 00000000000..4dea1262706
Binary files /dev/null and b/assets/img/posting_imgs/boj_1406-1.png differ
diff --git a/assets/img/posting_imgs/boj_1406-2.png b/assets/img/posting_imgs/boj_1406-2.png
new file mode 100644
index 00000000000..d27087fe8c4
Binary files /dev/null and b/assets/img/posting_imgs/boj_1406-2.png differ
diff --git a/assets/img/posting_imgs/boj_14712-1.png b/assets/img/posting_imgs/boj_14712-1.png
new file mode 100644
index 00000000000..b9662c186bd
Binary files /dev/null and b/assets/img/posting_imgs/boj_14712-1.png differ
diff --git a/assets/img/posting_imgs/boj_14712-2.png b/assets/img/posting_imgs/boj_14712-2.png
new file mode 100644
index 00000000000..bf92b4137da
Binary files /dev/null and b/assets/img/posting_imgs/boj_14712-2.png differ
diff --git a/assets/img/posting_imgs/cae-regular.png b/assets/img/posting_imgs/cae-regular.png
new file mode 100644
index 00000000000..5e104d6f0d2
Binary files /dev/null and b/assets/img/posting_imgs/cae-regular.png differ
diff --git a/assets/img/posting_imgs/cae.png b/assets/img/posting_imgs/cae.png
new file mode 100644
index 00000000000..7aae22e4403
Binary files /dev/null and b/assets/img/posting_imgs/cae.png differ
diff --git a/assets/img/posting_imgs/ch6-1.png b/assets/img/posting_imgs/ch6-1.png
new file mode 100644
index 00000000000..2615575e723
Binary files /dev/null and b/assets/img/posting_imgs/ch6-1.png differ
diff --git a/assets/img/posting_imgs/cross-entropy.png b/assets/img/posting_imgs/cross-entropy.png
new file mode 100644
index 00000000000..d8b1c72a304
Binary files /dev/null and b/assets/img/posting_imgs/cross-entropy.png differ
diff --git a/assets/img/posting_imgs/dae-graph.png b/assets/img/posting_imgs/dae-graph.png
new file mode 100644
index 00000000000..e060bed4d04
Binary files /dev/null and b/assets/img/posting_imgs/dae-graph.png differ
diff --git a/assets/img/posting_imgs/dae-sample1.png b/assets/img/posting_imgs/dae-sample1.png
new file mode 100644
index 00000000000..7ef7ed9a010
Binary files /dev/null and b/assets/img/posting_imgs/dae-sample1.png differ
diff --git a/assets/img/posting_imgs/dae-sample2.png b/assets/img/posting_imgs/dae-sample2.png
new file mode 100644
index 00000000000..5b027c2d7e1
Binary files /dev/null and b/assets/img/posting_imgs/dae-sample2.png differ
diff --git a/assets/img/posting_imgs/dae-smaple1.png b/assets/img/posting_imgs/dae-smaple1.png
new file mode 100644
index 00000000000..7ef7ed9a010
Binary files /dev/null and b/assets/img/posting_imgs/dae-smaple1.png differ
diff --git a/assets/img/posting_imgs/dae-smaple2.png b/assets/img/posting_imgs/dae-smaple2.png
new file mode 100644
index 00000000000..5b027c2d7e1
Binary files /dev/null and b/assets/img/posting_imgs/dae-smaple2.png differ
diff --git a/assets/img/posting_imgs/dae.png b/assets/img/posting_imgs/dae.png
new file mode 100644
index 00000000000..dcd6e19a2b8
Binary files /dev/null and b/assets/img/posting_imgs/dae.png differ
diff --git a/assets/img/posting_imgs/diabolo.jpg b/assets/img/posting_imgs/diabolo.jpg
new file mode 100644
index 00000000000..5aa4837581b
Binary files /dev/null and b/assets/img/posting_imgs/diabolo.jpg differ
diff --git a/assets/img/posting_imgs/docker-command1.png b/assets/img/posting_imgs/docker-command1.png
new file mode 100644
index 00000000000..63d6d720c78
Binary files /dev/null and b/assets/img/posting_imgs/docker-command1.png differ
diff --git a/assets/img/posting_imgs/docker-command2.png b/assets/img/posting_imgs/docker-command2.png
new file mode 100644
index 00000000000..ad4390332fc
Binary files /dev/null and b/assets/img/posting_imgs/docker-command2.png differ
diff --git a/assets/img/posting_imgs/docker-compose1.png b/assets/img/posting_imgs/docker-compose1.png
new file mode 100644
index 00000000000..4dca4a3b7be
Binary files /dev/null and b/assets/img/posting_imgs/docker-compose1.png differ
diff --git a/assets/img/posting_imgs/docker-lifecycle.png b/assets/img/posting_imgs/docker-lifecycle.png
new file mode 100644
index 00000000000..7db093a8701
Binary files /dev/null and b/assets/img/posting_imgs/docker-lifecycle.png differ
diff --git a/assets/img/posting_imgs/docker_structure.png b/assets/img/posting_imgs/docker_structure.png
new file mode 100644
index 00000000000..440fbfd02e6
Binary files /dev/null and b/assets/img/posting_imgs/docker_structure.png differ
diff --git a/assets/img/posting_imgs/entropy.png b/assets/img/posting_imgs/entropy.png
new file mode 100644
index 00000000000..ecc9d2dad02
Binary files /dev/null and b/assets/img/posting_imgs/entropy.png differ
diff --git a/assets/img/posting_imgs/forward.png b/assets/img/posting_imgs/forward.png
new file mode 100644
index 00000000000..9bdd04d2486
Binary files /dev/null and b/assets/img/posting_imgs/forward.png differ
diff --git a/assets/img/posting_imgs/kl-1.jpg b/assets/img/posting_imgs/kl-1.jpg
new file mode 100644
index 00000000000..0a2fb829790
Binary files /dev/null and b/assets/img/posting_imgs/kl-1.jpg differ
diff --git a/assets/img/posting_imgs/lab1-1.jpg b/assets/img/posting_imgs/lab1-1.jpg
new file mode 100644
index 00000000000..aafffc473d7
Binary files /dev/null and b/assets/img/posting_imgs/lab1-1.jpg differ
diff --git a/assets/img/posting_imgs/lab1-2.jpg b/assets/img/posting_imgs/lab1-2.jpg
new file mode 100644
index 00000000000..9779c2ff2ef
Binary files /dev/null and b/assets/img/posting_imgs/lab1-2.jpg differ
diff --git a/assets/img/posting_imgs/lab1-3.jpg b/assets/img/posting_imgs/lab1-3.jpg
new file mode 100644
index 00000000000..bf46f171e59
Binary files /dev/null and b/assets/img/posting_imgs/lab1-3.jpg differ
diff --git a/assets/img/posting_imgs/lab1-4.jpg b/assets/img/posting_imgs/lab1-4.jpg
new file mode 100644
index 00000000000..8f8206ba8d4
Binary files /dev/null and b/assets/img/posting_imgs/lab1-4.jpg differ
diff --git a/assets/img/posting_imgs/lab10-1-1.png b/assets/img/posting_imgs/lab10-1-1.png
new file mode 100644
index 00000000000..ab09668f00e
Binary files /dev/null and b/assets/img/posting_imgs/lab10-1-1.png differ
diff --git a/assets/img/posting_imgs/lab10-1-2.png b/assets/img/posting_imgs/lab10-1-2.png
new file mode 100644
index 00000000000..4d0573c5b57
Binary files /dev/null and b/assets/img/posting_imgs/lab10-1-2.png differ
diff --git a/assets/img/posting_imgs/lab10-1-3.png b/assets/img/posting_imgs/lab10-1-3.png
new file mode 100644
index 00000000000..ee358c5c028
Binary files /dev/null and b/assets/img/posting_imgs/lab10-1-3.png differ
diff --git a/assets/img/posting_imgs/lab10-1-4.png b/assets/img/posting_imgs/lab10-1-4.png
new file mode 100644
index 00000000000..d17e2542971
Binary files /dev/null and b/assets/img/posting_imgs/lab10-1-4.png differ
diff --git a/assets/img/posting_imgs/lab10-1-5.png b/assets/img/posting_imgs/lab10-1-5.png
new file mode 100644
index 00000000000..9b095361b9a
Binary files /dev/null and b/assets/img/posting_imgs/lab10-1-5.png differ
diff --git a/assets/img/posting_imgs/lab10-3-1.png b/assets/img/posting_imgs/lab10-3-1.png
new file mode 100644
index 00000000000..8d771744d0d
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-1.png differ
diff --git a/assets/img/posting_imgs/lab10-3-10.gif b/assets/img/posting_imgs/lab10-3-10.gif
new file mode 100644
index 00000000000..d3cd4029f90
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-10.gif differ
diff --git a/assets/img/posting_imgs/lab10-3-2.png b/assets/img/posting_imgs/lab10-3-2.png
new file mode 100644
index 00000000000..f535a7618d0
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-2.png differ
diff --git a/assets/img/posting_imgs/lab10-3-3.png b/assets/img/posting_imgs/lab10-3-3.png
new file mode 100644
index 00000000000..7c388b4045c
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-3.png differ
diff --git a/assets/img/posting_imgs/lab10-3-4.png b/assets/img/posting_imgs/lab10-3-4.png
new file mode 100644
index 00000000000..6605b653928
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-4.png differ
diff --git a/assets/img/posting_imgs/lab10-3-5.png b/assets/img/posting_imgs/lab10-3-5.png
new file mode 100644
index 00000000000..1fad776f797
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-5.png differ
diff --git a/assets/img/posting_imgs/lab10-3-6.png b/assets/img/posting_imgs/lab10-3-6.png
new file mode 100644
index 00000000000..32652c2015e
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-6.png differ
diff --git a/assets/img/posting_imgs/lab10-3-7.png b/assets/img/posting_imgs/lab10-3-7.png
new file mode 100644
index 00000000000..bb15c5aa310
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-7.png differ
diff --git a/assets/img/posting_imgs/lab10-3-8.png b/assets/img/posting_imgs/lab10-3-8.png
new file mode 100644
index 00000000000..74e59bb1466
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-8.png differ
diff --git a/assets/img/posting_imgs/lab10-3-9.gif b/assets/img/posting_imgs/lab10-3-9.gif
new file mode 100644
index 00000000000..f657595a287
Binary files /dev/null and b/assets/img/posting_imgs/lab10-3-9.gif differ
diff --git a/assets/img/posting_imgs/lab10-4-1.png b/assets/img/posting_imgs/lab10-4-1.png
new file mode 100644
index 00000000000..0cb128d539c
Binary files /dev/null and b/assets/img/posting_imgs/lab10-4-1.png differ
diff --git a/assets/img/posting_imgs/lab10-5-1.png b/assets/img/posting_imgs/lab10-5-1.png
new file mode 100644
index 00000000000..a3413d3f651
Binary files /dev/null and b/assets/img/posting_imgs/lab10-5-1.png differ
diff --git a/assets/img/posting_imgs/lab10-5-2.png b/assets/img/posting_imgs/lab10-5-2.png
new file mode 100644
index 00000000000..775a8652ec9
Binary files /dev/null and b/assets/img/posting_imgs/lab10-5-2.png differ
diff --git a/assets/img/posting_imgs/lab10-5-3.png b/assets/img/posting_imgs/lab10-5-3.png
new file mode 100644
index 00000000000..4138fbe536b
Binary files /dev/null and b/assets/img/posting_imgs/lab10-5-3.png differ
diff --git a/assets/img/posting_imgs/lab10-5-4.png b/assets/img/posting_imgs/lab10-5-4.png
new file mode 100644
index 00000000000..365ea67e471
Binary files /dev/null and b/assets/img/posting_imgs/lab10-5-4.png differ
diff --git a/assets/img/posting_imgs/lab10-6-1.png b/assets/img/posting_imgs/lab10-6-1.png
new file mode 100644
index 00000000000..3911afd0731
Binary files /dev/null and b/assets/img/posting_imgs/lab10-6-1.png differ
diff --git a/assets/img/posting_imgs/lab10-6-2.png b/assets/img/posting_imgs/lab10-6-2.png
new file mode 100644
index 00000000000..8603598c7d4
Binary files /dev/null and b/assets/img/posting_imgs/lab10-6-2.png differ
diff --git a/assets/img/posting_imgs/lab10-6-3.png b/assets/img/posting_imgs/lab10-6-3.png
new file mode 100644
index 00000000000..9f565d17976
Binary files /dev/null and b/assets/img/posting_imgs/lab10-6-3.png differ
diff --git a/assets/img/posting_imgs/lab10-6-4.png b/assets/img/posting_imgs/lab10-6-4.png
new file mode 100644
index 00000000000..3d85543ffd9
Binary files /dev/null and b/assets/img/posting_imgs/lab10-6-4.png differ
diff --git a/assets/img/posting_imgs/lab10-6-5.png b/assets/img/posting_imgs/lab10-6-5.png
new file mode 100644
index 00000000000..aa0fd929bbc
Binary files /dev/null and b/assets/img/posting_imgs/lab10-6-5.png differ
diff --git a/assets/img/posting_imgs/lab10-6-6.png b/assets/img/posting_imgs/lab10-6-6.png
new file mode 100644
index 00000000000..da93695f7db
Binary files /dev/null and b/assets/img/posting_imgs/lab10-6-6.png differ
diff --git a/assets/img/posting_imgs/lab11-0-1.png b/assets/img/posting_imgs/lab11-0-1.png
new file mode 100644
index 00000000000..9fbdad919a5
Binary files /dev/null and b/assets/img/posting_imgs/lab11-0-1.png differ
diff --git a/assets/img/posting_imgs/lab11-0-2.png b/assets/img/posting_imgs/lab11-0-2.png
new file mode 100644
index 00000000000..ff46086d809
Binary files /dev/null and b/assets/img/posting_imgs/lab11-0-2.png differ
diff --git a/assets/img/posting_imgs/lab11-0-3.png b/assets/img/posting_imgs/lab11-0-3.png
new file mode 100644
index 00000000000..83a446126b0
Binary files /dev/null and b/assets/img/posting_imgs/lab11-0-3.png differ
diff --git a/assets/img/posting_imgs/lab11-1-1.png b/assets/img/posting_imgs/lab11-1-1.png
new file mode 100644
index 00000000000..e26898584ba
Binary files /dev/null and b/assets/img/posting_imgs/lab11-1-1.png differ
diff --git a/assets/img/posting_imgs/lab11-1-2.png b/assets/img/posting_imgs/lab11-1-2.png
new file mode 100644
index 00000000000..a90f84590e7
Binary files /dev/null and b/assets/img/posting_imgs/lab11-1-2.png differ
diff --git a/assets/img/posting_imgs/lab11-3-1.png b/assets/img/posting_imgs/lab11-3-1.png
new file mode 100644
index 00000000000..ebfe6f4e4aa
Binary files /dev/null and b/assets/img/posting_imgs/lab11-3-1.png differ
diff --git a/assets/img/posting_imgs/lab11-4-1.png b/assets/img/posting_imgs/lab11-4-1.png
new file mode 100644
index 00000000000..5bef7a42e4f
Binary files /dev/null and b/assets/img/posting_imgs/lab11-4-1.png differ
diff --git a/assets/img/posting_imgs/lab11-4-2.png b/assets/img/posting_imgs/lab11-4-2.png
new file mode 100644
index 00000000000..2160aeb2496
Binary files /dev/null and b/assets/img/posting_imgs/lab11-4-2.png differ
diff --git a/assets/img/posting_imgs/lab11-4-3.png b/assets/img/posting_imgs/lab11-4-3.png
new file mode 100644
index 00000000000..5e7840b475d
Binary files /dev/null and b/assets/img/posting_imgs/lab11-4-3.png differ
diff --git a/assets/img/posting_imgs/lab11-4-4.png b/assets/img/posting_imgs/lab11-4-4.png
new file mode 100644
index 00000000000..6a77c0aa6b6
Binary files /dev/null and b/assets/img/posting_imgs/lab11-4-4.png differ
diff --git a/assets/img/posting_imgs/lab11-5-1.png b/assets/img/posting_imgs/lab11-5-1.png
new file mode 100644
index 00000000000..f1b8566c4bf
Binary files /dev/null and b/assets/img/posting_imgs/lab11-5-1.png differ
diff --git a/assets/img/posting_imgs/lab11-5-2.png b/assets/img/posting_imgs/lab11-5-2.png
new file mode 100644
index 00000000000..5948c3e2ef3
Binary files /dev/null and b/assets/img/posting_imgs/lab11-5-2.png differ
diff --git a/assets/img/posting_imgs/lab2-1.png b/assets/img/posting_imgs/lab2-1.png
new file mode 100644
index 00000000000..cc39ad6f4b4
Binary files /dev/null and b/assets/img/posting_imgs/lab2-1.png differ
diff --git a/assets/img/posting_imgs/lab3-1.png b/assets/img/posting_imgs/lab3-1.png
new file mode 100644
index 00000000000..61da3d05748
Binary files /dev/null and b/assets/img/posting_imgs/lab3-1.png differ
diff --git a/assets/img/posting_imgs/lab3-2.gif b/assets/img/posting_imgs/lab3-2.gif
new file mode 100644
index 00000000000..e19b5a814f8
Binary files /dev/null and b/assets/img/posting_imgs/lab3-2.gif differ
diff --git a/assets/img/posting_imgs/lab3-3.gif b/assets/img/posting_imgs/lab3-3.gif
new file mode 100644
index 00000000000..c42b25c7381
Binary files /dev/null and b/assets/img/posting_imgs/lab3-3.gif differ
diff --git a/assets/img/posting_imgs/lab3-4.jpg b/assets/img/posting_imgs/lab3-4.jpg
new file mode 100644
index 00000000000..9760d379859
Binary files /dev/null and b/assets/img/posting_imgs/lab3-4.jpg differ
diff --git a/assets/img/posting_imgs/lab4-1.png b/assets/img/posting_imgs/lab4-1.png
new file mode 100644
index 00000000000..77611c82cde
Binary files /dev/null and b/assets/img/posting_imgs/lab4-1.png differ
diff --git a/assets/img/posting_imgs/lab4_2-1.png b/assets/img/posting_imgs/lab4_2-1.png
new file mode 100644
index 00000000000..fdfe1b879e0
Binary files /dev/null and b/assets/img/posting_imgs/lab4_2-1.png differ
diff --git a/assets/img/posting_imgs/lab4_2-2.png b/assets/img/posting_imgs/lab4_2-2.png
new file mode 100644
index 00000000000..984996ba069
Binary files /dev/null and b/assets/img/posting_imgs/lab4_2-2.png differ
diff --git a/assets/img/posting_imgs/lab5-1.png b/assets/img/posting_imgs/lab5-1.png
new file mode 100644
index 00000000000..95c872933f1
Binary files /dev/null and b/assets/img/posting_imgs/lab5-1.png differ
diff --git a/assets/img/posting_imgs/lab5-2.png b/assets/img/posting_imgs/lab5-2.png
new file mode 100644
index 00000000000..37a06f92af6
Binary files /dev/null and b/assets/img/posting_imgs/lab5-2.png differ
diff --git a/assets/img/posting_imgs/lab5-3.png b/assets/img/posting_imgs/lab5-3.png
new file mode 100644
index 00000000000..c6a05163503
Binary files /dev/null and b/assets/img/posting_imgs/lab5-3.png differ
diff --git a/assets/img/posting_imgs/lab5-4.png b/assets/img/posting_imgs/lab5-4.png
new file mode 100644
index 00000000000..ff81f22b6a6
Binary files /dev/null and b/assets/img/posting_imgs/lab5-4.png differ
diff --git a/assets/img/posting_imgs/lab5-5.png b/assets/img/posting_imgs/lab5-5.png
new file mode 100644
index 00000000000..279a7f212c7
Binary files /dev/null and b/assets/img/posting_imgs/lab5-5.png differ
diff --git a/assets/img/posting_imgs/lab6-1.png b/assets/img/posting_imgs/lab6-1.png
new file mode 100644
index 00000000000..0a8ffb2a214
Binary files /dev/null and b/assets/img/posting_imgs/lab6-1.png differ
diff --git a/assets/img/posting_imgs/lab6-2.png b/assets/img/posting_imgs/lab6-2.png
new file mode 100644
index 00000000000..77b6204a4a5
Binary files /dev/null and b/assets/img/posting_imgs/lab6-2.png differ
diff --git a/assets/img/posting_imgs/lab6-3.png b/assets/img/posting_imgs/lab6-3.png
new file mode 100644
index 00000000000..f3858c688e4
Binary files /dev/null and b/assets/img/posting_imgs/lab6-3.png differ
diff --git a/assets/img/posting_imgs/lab6-4.png b/assets/img/posting_imgs/lab6-4.png
new file mode 100644
index 00000000000..653317e114f
Binary files /dev/null and b/assets/img/posting_imgs/lab6-4.png differ
diff --git a/assets/img/posting_imgs/lab7-1-1.jpg b/assets/img/posting_imgs/lab7-1-1.jpg
new file mode 100644
index 00000000000..3ff3a8adabb
Binary files /dev/null and b/assets/img/posting_imgs/lab7-1-1.jpg differ
diff --git a/assets/img/posting_imgs/lab7-1-2.jpg b/assets/img/posting_imgs/lab7-1-2.jpg
new file mode 100644
index 00000000000..2cecdb34943
Binary files /dev/null and b/assets/img/posting_imgs/lab7-1-2.jpg differ
diff --git a/assets/img/posting_imgs/lab7-1-3.jpg b/assets/img/posting_imgs/lab7-1-3.jpg
new file mode 100644
index 00000000000..16a1f54d35e
Binary files /dev/null and b/assets/img/posting_imgs/lab7-1-3.jpg differ
diff --git a/assets/img/posting_imgs/lab7-2-1.png b/assets/img/posting_imgs/lab7-2-1.png
new file mode 100644
index 00000000000..d888e573b10
Binary files /dev/null and b/assets/img/posting_imgs/lab7-2-1.png differ
diff --git a/assets/img/posting_imgs/lab8-1-1.svg b/assets/img/posting_imgs/lab8-1-1.svg
new file mode 100644
index 00000000000..2703d5c96be
--- /dev/null
+++ b/assets/img/posting_imgs/lab8-1-1.svg
@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   inkscape:output_extension="org.inkscape.output.svg.inkscape"
+   inkscape:version="0.46+devel"
+   version="1.1"
+   id="neuron"
+   height="633.71252"
+   width="1179">
+  <defs>
+	<style type="text/css">
+		#Lines {
+			stroke: #000000;
+			stroke-width: 2;
+			stroke-linecap: round;
+		}
+		#Cell {
+			stroke: #000000;
+			stroke-width: 2;
+			fill-opacity: 1;
+		}
+		#Cell_Body {
+			fill: #a88fd1;
+		}
+		#Cell_Body_Nucleus {
+			fill: #2d7132;
+		}
+		#Small_Cell {
+			fill: #f4cc4b;
+		}
+		#Small_Cell_Nucleus {
+			fill: #d79b9b;
+		}
+	</style>
+  </defs>
+  <metadata>
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+        <dc:creator>
+          <cc:Agent>
+            <dc:title>Quasar Jarosz, quasarj.com</dc:title>
+          </cc:Agent>
+        </dc:creator>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+
+	<g id="Cell">
+	  <g id="Cell_Body">
+		<path
+		   d="m 206.10019,562.12434 9.15955,-26.50534 c -10.51421,4.83421 -27.28139,21.72124 -37.92788,19.61846 17.6415,-14.68138 34.76421,-27.05882 45.25952,-51.8195 13.4532,-27.60799 7.45818,-39.6122 -17.22962,-37.91724 -23.27537,1.59799 -47.03719,19.66233 -46.09678,60.0172 0.37993,16.30314 -5.41737,24.29246 -5.83139,7.43195 -0.13461,-5.48195 -3.76506,-5.13328 -7.70584,-1.93448 -12.8434,10.96517 13.4041,-45.58961 11.04747,-54.00791 -10.0857,3.25724 -34.1671,59.65839 -38.5198,53.26042 2.04742,-14.12157 0.25958,-18.55586 -8.72538,-2.00634 -3.03536,5.59086 -12.149223,18.29181 -14.250423,15.62944 7.329613,-18.97188 21.196723,-35.17271 28.571583,-54.25907 0,-0.93787 -7.32675,1.57547 -16.28167,5.58517 -18.658408,8.35464 -29.102304,7.48607 -20.590964,-1.71247 5.097827,-5.5094 60.166844,-28.78842 95.508254,-40.37368 29.65528,-9.72128 35.41948,-13.36886 35.34439,-22.36588 -0.0733,-8.78132 -6.99049,-17.06972 -17.7263,-24.6791 -14.96231,-10.60505 -38.92235,-1.94276 -61.31584,26.06834 -7.76558,8.95175 -11.8845,22.32535 -24.77187,22.6667 1.55876,-4.05277 -0.0326,-13.2119 8.29321,-20.05803 4.05261,-3.33238 8.9924,-10.77915 11.64765,-15.80116 4.78107,-9.04267 7.99466,-13.11281 7.99466,-13.11281 0,0 -51.473867,9.5788 -51.528938,9.69812 12.784208,-7.09789 13.277368,-6.18656 6.58278,-18.68519 -5.641419,-12.47346 -6.054443,-17.30768 -4.628489,-54.17443 1.557696,-40.27299 6.056125,-55.35828 6.056125,-55.35828 1.064084,8.74669 4.710682,17.77651 11.228742,0.14587 0,0 -1.26066,1.22308 -3.4372,34.74652 -2.59029,39.89596 6.69203,65.80891 20.9806,67.64361 7.43359,0.95449 39.51224,0.77143 41.9285,-2.43461 -4.23792,-11.04197 -25.2457,-10.84245 -34.23508,-17.25976 -0.0558,-1.26593 5.76518,-1.66478 11.94726,-3.47632 10.05999,-2.94792 12.11977,-0.91634 25.64545,5.78724 28.41708,16.44721 16.7838,7.24213 16.39198,-11.87788 0,0 7.21142,8.46211 12.59044,13.596 15.91109,15.18602 23.58025,8.27456 22.2708,-16.89379 -0.91522,-17.59113 -4.92075,-39.92126 -25.46743,-65.00174 -11.90496,-14.53188 -9.44755,-21.60951 -20.49695,-23.87472 -27.81251,5.7201 -43.69053,-22.25643 -53.62315,-27.22191 -6.56887,0 -26.408412,-9.53626 -29.977829,-12.13619 -12.392718,-14.56281 24.053939,1.6087 29.659879,0.53476 -1.3655,-17.85061 -43.825565,-61.63272 -42.934502,-59.95147 11.939616,-3.83312 1.517981,-29.03796 1.660697,-36.34523 6.039415,7.53271 8.241863,5.72648 10.847846,-2.22515 -0.958071,29.17636 1.144563,45.27193 20.202669,63.55244 17.12317,19.75675 27.01277,52.96178 52.54681,60.04644 6.35988,2.05288 12.19671,2.33423 15.062,0.80864 5.64336,-3.00474 9.55451,-9.20036 -28.75399,-56.53963 -22.88712,-28.28247 -29.94427,-39.78243 -26.34149,-45.03571 5.29253,-1.00587 6.31039,1.3085 15.22618,11.35 l 11.12333,12.52776 1.47253,-9.65334 c 1.52105,-8.68641 0.32169,-30.75763 -8.16374,-43.42776 -4.85032,-7.24232 3.8959,-5.83154 8.47011,2.70705 l 4.14494,7.73728 2.01567,-8.97587 c 2.55656,-11.38449 5.23969,-19.89155 5.23969,-19.89155 -0.58216,11.04051 1.57917,14.97649 8.47424,9.30581 -0.58825,31.54194 -25.45781,59.26435 -1.76475,94.62583 l 6.19144,-10.2634 c 4.92093,-8.15731 8.14345,-16.57384 7.59407,-41.10875 -0.52226,-23.32384 4.53918,-42.97656 6.91139,-43.37193 1.61885,11.34349 -2.25468,26.22128 4.82999,37.26112 0.43504,-10.11579 8.33587,-26.49759 9.29183,-25.18314 0.73709,0 0.52922,7.60863 -9.71822,44.30407 -9.47499,33.92935 -6.34544,60.36647 1.88951,78.21518 5.73113,12.42184 10.9157,11.1314 12.02573,4.70575 0.68277,-3.95233 0.74081,-20.44431 0.12899,-36.64884 -1.09996,-29.13318 -0.92946,-34.04106 -0.92946,-34.04106 -0.40994,8.7453 15.20481,23.05148 30.07077,-14.23077 4.74118,-11.89039 13.77718,-24.24188 13.77718,-24.24188 -6.16716,17.32136 -6.39798,27.68267 -6.01177,30.91983 1.18441,0.79909 11.68121,-3.61174 17.03423,-7.6215 -0.0865,-0.13364 -33.9585,42.36228 -35.92407,57.72103 9.50964,8.10982 28.63918,-28.63812 28.63918,-28.63812 0.0929,-0.46465 2.4572,10.21891 2.22939,11.35796 0.65431,0.27957 12.74283,-9.58241 13.10542,-8.67613 0.82093,-0.84618 -11.07821,18.01899 -28.56239,31.1105 -28.41823,27.69031 -19.51495,62.23686 -9.24191,78.38253 6.9767,14.09569 35.11872,32.88772 46.19536,35.60677 17.66765,4.33698 19.65788,-21.02855 3.80785,-48.53147 -11.47017,-19.90303 -18.54356,-52.64068 -14.97862,-62.03821 3.33812,-8.79961 5.56444,1.25887 13.02355,8.91587 3.23357,3.31936 3.89187,-6.57438 2.70462,-25.99535 -1.59719,-26.12704 -3.50444,-32.71279 0.77739,-32.71279 2.65569,0 5.07851,5.04349 5.07851,6.62442 0,1.58093 2.78034,-0.14035 5.25307,-5.8e-4 3.59401,0.20314 0.017,22.52876 -1.28955,25.71744 -1.84595,4.50506 10.38161,-15.20065 14.00774,-24.91712 2.81794,-7.55086 4.09165,-26.08338 4.09165,-26.08338 -0.26907,0.4815 2.5962,18.46875 7.95126,15.9556 2.77786,-1.30366 1.82252,1.2042 3.43892,1.2042 1.6164,0 3.81392,-3.43734 3.81392,-9.93021 0,-8.95239 0.99688,-11.43106 4.12518,-10.25696 2.89621,1.08699 5.00677,-3.8848 9.58389,-15.85532 3.95629,-10.34688 5.59114,-22.88364 8.25145,-22.88364 4.89855,0 2.42936,17.34702 -5.57579,54.32219 -9.98521,46.12102 -6.19331,45.68987 12.99121,19.08326 6.83951,-9.48558 14.02013,-20.25171 16.38904,-20.25171 5.78767,0 -8.70151,26.73018 -8.70151,26.73018 0,0 7.92587,0.5413 11.47395,2.54434 2.19193,1.23744 -5.8897,8.55407 -25.95272,23.17558 -22.21131,16.18716 -21.5258,21.16244 -34.15122,68.2219 -15.16834,41.0017 29.49489,70.17829 61.79013,75.05155 43.09181,12.708 78.5422,23.95443 110.50191,33.41967 37.64565,11.14919 71.01235,20.77385 111.7988,21.92529 37.34666,1.05432 76.97284,-2.35046 112.79231,-13.80032 32.96277,-10.5367 62.70182,-27.1793 84.47406,-54.13663 36.3213,-44.97126 60.83967,-89.49681 60.83967,-89.49681 10.42143,-29.28989 27.27811,-55.71586 24.16208,-87.9319 -1.84051,-11.52196 -14.32393,-20.48389 -21.49321,-13.28918 -2.2659,2.27394 -7.27424,9.22331 -11.11732,9.22331 -9.16119,0 -13.10183,-7.09837 -4.0872,-13.01581 l 10.32488,-3.81033 c -4.66954,-15.71587 -26.59131,-11.81438 -14.26371,-24.64203 10.9587,-8.25589 19.46049,-6.0614 16.74362,3.64491 -1.17381,4.19352 5.12274,9.55759 16.42617,14.6598 15.33268,6.92094 16.33016,3.19706 16.9465,1.91129 0.94138,-1.96385 1.20097,-6.18229 3.74909,-8.25064 3.3539,-2.72239 9.42152,-3.08563 8.07174,-10.12264 -1.83683,-9.57626 -4.90202,-17.48536 4.67544,-16.58577 8.16702,0.7671 1.43107,11.07411 5.10959,14.93337 6.18452,6.48841 22.45952,-7.90525 26.60552,6.62193 -0.86854,4.30194 -2.45389,7.19487 -12.51502,5.4044 -10.07031,-1.7921 -18.18955,-0.91497 -24.28104,11.81893 -4.2911,8.97028 -11.27708,39.7811 -6.32528,37.8284 1.52998,-0.60333 19.41333,-10.39283 33.69109,-18.29748 29.74202,-16.46618 50.94539,-32.40752 49.59866,-44.96487 -0.63715,-5.94104 -0.12643,-13.27733 5.76122,-15.90105 13.3023,-5.9279 13.4226,-0.92628 10.99472,9.85609 -1.83871,8.16588 2.49458,7.96221 4.07908,8.2707 0.2398,1.43129 -17.97844,15.75121 -17.97844,15.75121 0,0 28.02184,-12.38916 28.02184,-6.15109 0,7.48812 -5.7145,10.54312 -25.78289,16.22891 -9.55621,2.70746 -24.68003,11.41291 -32.09607,16.53666 -17.3999,14.76428 -52.38504,19.80878 -58.71269,45.46372 -4.85089,10.31296 -8.00562,15.39071 -5.28028,17.08418 6.27488,3.89909 14.90889,5.31394 30.23432,-10.35374 8.24654,-8.43071 18.6501,-16.81933 23.11902,-18.64138 4.46893,-1.82205 9.60588,-6.58197 11.49267,-10.54121 4.5359,-9.51812 11.34341,-17.18611 11.09023,-4.7996 -0.15006,7.34162 3.88745,8.11539 12.12916,-1.79075 8.6294,-10.37213 15.29091,-4.79734 12.47575,8.52651 -1.53874,7.28272 -31.07996,9.16091 -31.87911,13.12425 0,2.52643 20.29643,2.56267 18.52289,3.57682 -12.73442,8.38544 -31.05275,4.4683 -40.21122,17.49055 l 23.11415,3.17079 c 8.82372,1.35502 18.83121,4.25041 22.23888,6.43419 3.40767,2.18379 15.99059,6.82354 27.96209,10.31055 19.9217,5.80273 33.4556,11.56869 33.859,16.91597 0.4349,5.76601 -38.2613,-6.9091 -61.36459,-16.4349 -4.65106,-1.9177 13.16121,11.80812 19.56379,21.32801 4.6898,6.97314 9.522,18.30594 9.7251,30.97964 0.3703,23.09753 5.3938,25.00762 19.535,29.35419 13.6724,4.20248 13.0029,13.11332 -0.9181,14.26094 -21.3486,-2.88954 -27.3931,-21.36522 -31.1862,-39.23452 -7.51434,6.89746 -21.92903,25.42839 -25.77056,14.10337 0,-2.98003 1.52009,-6.64138 5.53858,-9.21663 12.80478,-8.20586 20.05838,-18.02764 16.54345,-27.90257 -5.80284,-16.30263 -58.11256,-54.02162 -74.15676,-41.005 -3.3098,2.68524 4.57823,8.40132 9.20417,17.77449 7.46717,15.13007 7.74482,28.08875 5.74107,31.25972 -0.94666,1.49815 -9.51,1.35787 -9.38298,-2.43245 0.68989,-20.58605 -5.60284,-31.31159 -8.1861,-32.89696 -1.77429,-0.88714 -2.64718,11.42671 2.11032,40.11989 0.49433,2.98138 -1.55129,3.89398 -4.73752,3.89398 -8.33001,0 -11.37904,-4.39327 -8.65623,-12.30111 2.82323,-8.1995 -0.0597,-18.16889 -2.9348,-26.53804 -3.90222,-11.35915 -14.50433,-17.18589 -24.46651,-5.69772 -3.42162,3.82591 -6.61913,7.75079 -9.63322,11.73949 -25.26648,33.43653 -37.6431,71.35789 -61.09489,93.05976 -28.24525,26.13764 -57.79436,45.38731 -90.94878,56.63754 -35.29201,11.97558 -74.2686,15.88849 -118.85279,12.53035 -35.82994,-2.69875 -74.69585,-14.63263 -119.11068,-23.65079 L 378.51481,391.28522 c -25.08672,4.19365 -53.11343,29.31311 -54.72524,37.92606 -2.59082,13.84444 21.13857,25.59557 54.36085,33.21398 15.59905,6.18469 16.20771,8.18135 -0.81758,6.21272 l -16.08118,-0.73031 c 3.8988,8.58738 16.38387,12.48286 17.86552,17.82229 -10.76525,8.9836 -76.7878,-48.80052 -78.53318,-33.81678 -6.94573,32.46941 94.2912,80.03175 65.62442,78.35328 -6.10325,-1.09156 -13.34289,-2.80486 -15.4017,-3.10983 -5.88905,-0.87235 -12.65875,5.13876 -5.90693,13.47499 3.7428,4.62111 10.37941,12.33433 6.90107,14.14932 -17.2671,-7.74045 -21.22945,-35.34039 -39.31559,-41.95567 -7.61499,6.75803 -0.21313,24.23533 -8.04736,30.77921 -0.39896,-27.13664 -0.66067,-54.26924 -16.69001,-81.86559 l -16.67118,0 -20.56028,0 c 2.80394,17.07876 7.97601,82.31534 4.52538,75.61876 -5.04043,-9.78187 -9.86547,-20.31762 -13.96961,-33.37651 -8.61666,10.62045 -17.25442,47.47176 -17.89732,63.26132 -3.23268,-12.44911 -6.80512,-15.87207 -17.0747,-5.11812 z M 313.64481,267.34063 c 11.79033,-22.94295 15.59285,-68.76616 12.85507,-77.58094 -2.82313,-9.08959 -46.22661,72.0161 -36.06646,84.77974 5.49597,6.90429 12.29168,19.208 15.69586,15.69517 1.27813,-1.31892 4.04137,-11.82746 7.51553,-22.89397 z" />
+		<path
+		   d="m 266.25,388.46252 c -8.25762,-4.41371 -14.25,0.55102 -14.25,8.75 0,9.80419 29.85389,42.39612 37.75,34.5 15.63549,-15.63549 -6.30338,-38.51334 -23.5,-43.25 z"
+		   id="Cell_Body_Nucleus" />
+	  </g>
+	  
+	  <g id="Neck">
+		<g id="Small_Cell">
+		  <path
+			 d="m 383.5,371.21252 c 29.73372,-6.58867 57.99394,6.95485 85.67244,16.25008 7.07584,2.89756 13.29553,8.28646 16.44747,15.33189 -0.56539,12.48331 -13.66954,22.60671 -25.89067,20.1049 -20.81927,0.40026 -42.50084,-2.0186 -60.90562,-12.46069 -8.69775,-3.84797 -18.16183,-9.38592 -20.95585,-19.13922 -1.20874,-7.14958 1.79888,-14.2115 5.63223,-20.08696 z" />
+		  <path
+			 d="m 501.5,404.21252 c 15.08462,-3.53005 27.29865,0.15973 41.5,3 12.00667,2.40134 28.84181,3.17091 39.5,8.5 45.00023,38.83122 -25.706,35.66934 -48.5,31.5 -26.30051,-6.06979 -61.87157,-25.90395 -32.5,-43 z" />
+		  <path
+			 d="m 611.5,425.21252 c 14.64803,-4.33339 95.06743,-24.05147 100,-2.5 8.37238,36.58079 -55.74893,39.70067 -79,35 -10.97104,-2.21802 -38.41754,-16.10662 -21,-32.5 z" />
+		  <path
+			 d="m 722,409.71252 c 5.92668,-11.24195 73.1895,-64.06211 87,-32 6.86822,15.94509 -89.40974,77.84937 -89,45.5 0.0717,-5.65801 -1.9929,-7.5071 2,-13.5 z" />
+		  <path
+			 d="m 820.9375,369.33752 c 12.56161,-1.96628 17.82959,-14.39208 28.0625,-24.625 14.72196,-14.72195 29.5,-37.40007 29.5,-57.5 0,-4.65766 -23.61268,-17.88732 -27.76777,-13.73223 -10.89772,10.89772 -81.07245,90.72946 -29.79473,95.85723 z" />
+		</g>
+		<g id="Small_Cell_Nucleus">
+		  <path
+			 d="m 415.25,393.46252 c 3.0616,-0.52019 5.33182,-0.93522 7.125,-3.625 5.59213,-8.38819 -10.05311,-8.89896 -14.25,-7.5 -8.56188,2.85396 0.006,12.33449 7.125,11.125 z" />
+		  <path
+			 d="m 536.375,434.83752 c 3.28921,-0.30585 6.25799,-0.88298 8.5,-3.125 7.28578,-7.28577 -8.20639,-9.72287 -12.625,-8.25 -7.16886,2.38962 -2.83373,12.02205 4.125,11.375 z" />
+		  <path
+			 d="m 657.875,443.96252 c 24.45312,1.4981 12.67565,-21.01602 -3.5,-11.375 -5.2911,3.1536 -1.42525,11.375 3.5,11.375 z" />
+		  <path
+			 d="m 764.25,389.96252 c -3.03826,0.0784 -5.71193,2.14129 -8.125,3.75 -8.41496,5.60998 3.46629,13.49195 10.1224,10.8295 11.0124,-4.40496 9.92954,-15.86724 -1.9974,-14.5795 z" />
+		  <path
+			 d="m 834.53661,327.66963 c 2.40255,0.89066 5.90239,-2.42089 7.15533,-4.92678 0.81335,-1.62668 2.13637,-3.48291 2.60356,-5.35355 5.24667,-21.00799 -28.03168,3.50628 -9.75889,10.28033 z" />
+		</g>
+	  </g>
+	</g>
+	
+  <g
+     id="Lines">
+    <path
+       d="M 223.77999,192.41409 218.496,53.177857"
+       id="path10"
+       sodipodi:nodetypes="cc" />
+    <path
+       d="M 330.19282,348.45961 414.36457,241.26826"
+       id="path12"
+       sodipodi:nodetypes="cc" />
+    <path
+       d="M 130.81475,591.28612 264.32592,417.66392"
+       id="path14"
+       sodipodi:nodetypes="cc" />
+    <path
+       d="m 671.75144,542.49575 -1.9542,-83.65782"
+       id="path16"
+       sodipodi:nodetypes="cc" />
+    <path
+       d="M 895.90429,472.49218 770.18124,403.22177"
+       id="path18"
+       sodipodi:nodetypes="cc" />
+    <path
+       d="m 758.01847,220.76216 41.15415,140.26411"
+       id="path20"
+       sodipodi:nodetypes="cc" />
+    <path
+       d="m 1030.9617,104.08955 3.6191,164.16467"
+       id="path22"
+       sodipodi:nodetypes="cc" />
+  </g>
+</svg>
diff --git a/assets/img/posting_imgs/lab8-1-2.png b/assets/img/posting_imgs/lab8-1-2.png
new file mode 100644
index 00000000000..fcbe7db475e
Binary files /dev/null and b/assets/img/posting_imgs/lab8-1-2.png differ
diff --git a/assets/img/posting_imgs/lab8-1-3.jpg b/assets/img/posting_imgs/lab8-1-3.jpg
new file mode 100644
index 00000000000..a6510f00286
Binary files /dev/null and b/assets/img/posting_imgs/lab8-1-3.jpg differ
diff --git a/assets/img/posting_imgs/lab8-1-4.jpg b/assets/img/posting_imgs/lab8-1-4.jpg
new file mode 100644
index 00000000000..7949a129a4a
Binary files /dev/null and b/assets/img/posting_imgs/lab8-1-4.jpg differ
diff --git a/assets/img/posting_imgs/lab8-2-1.jpg b/assets/img/posting_imgs/lab8-2-1.jpg
new file mode 100644
index 00000000000..bdc1812d76c
Binary files /dev/null and b/assets/img/posting_imgs/lab8-2-1.jpg differ
diff --git a/assets/img/posting_imgs/lab9-1-1.png b/assets/img/posting_imgs/lab9-1-1.png
new file mode 100644
index 00000000000..fd32e29637d
Binary files /dev/null and b/assets/img/posting_imgs/lab9-1-1.png differ
diff --git a/assets/img/posting_imgs/lab9-1-2.png b/assets/img/posting_imgs/lab9-1-2.png
new file mode 100644
index 00000000000..b9dbbede88b
Binary files /dev/null and b/assets/img/posting_imgs/lab9-1-2.png differ
diff --git a/assets/img/posting_imgs/lab9-2-1.png b/assets/img/posting_imgs/lab9-2-1.png
new file mode 100644
index 00000000000..1334637edfc
Binary files /dev/null and b/assets/img/posting_imgs/lab9-2-1.png differ
diff --git a/assets/img/posting_imgs/lab9-2-2.png b/assets/img/posting_imgs/lab9-2-2.png
new file mode 100644
index 00000000000..ac6f48a78ac
Binary files /dev/null and b/assets/img/posting_imgs/lab9-2-2.png differ
diff --git a/assets/img/posting_imgs/lab9-2-3.png b/assets/img/posting_imgs/lab9-2-3.png
new file mode 100644
index 00000000000..19225343a54
Binary files /dev/null and b/assets/img/posting_imgs/lab9-2-3.png differ
diff --git a/assets/img/posting_imgs/lab9-2-4.png b/assets/img/posting_imgs/lab9-2-4.png
new file mode 100644
index 00000000000..a8fb0c79939
Binary files /dev/null and b/assets/img/posting_imgs/lab9-2-4.png differ
diff --git a/assets/img/posting_imgs/lab9-3-1.png b/assets/img/posting_imgs/lab9-3-1.png
new file mode 100644
index 00000000000..464978e6f1e
Binary files /dev/null and b/assets/img/posting_imgs/lab9-3-1.png differ
diff --git a/assets/img/posting_imgs/lab9-4-1.png b/assets/img/posting_imgs/lab9-4-1.png
new file mode 100644
index 00000000000..ae4cb39c6be
Binary files /dev/null and b/assets/img/posting_imgs/lab9-4-1.png differ
diff --git a/assets/img/posting_imgs/lab9-4-2.png b/assets/img/posting_imgs/lab9-4-2.png
new file mode 100644
index 00000000000..6b8460cff0e
Binary files /dev/null and b/assets/img/posting_imgs/lab9-4-2.png differ
diff --git a/assets/img/posting_imgs/lab9-4-3.png b/assets/img/posting_imgs/lab9-4-3.png
new file mode 100644
index 00000000000..595cc2b07f0
Binary files /dev/null and b/assets/img/posting_imgs/lab9-4-3.png differ
diff --git a/assets/img/posting_imgs/net_test.png b/assets/img/posting_imgs/net_test.png
new file mode 100644
index 00000000000..2468bf3f62e
Binary files /dev/null and b/assets/img/posting_imgs/net_test.png differ
diff --git a/assets/img/posting_imgs/proxy.png b/assets/img/posting_imgs/proxy.png
new file mode 100644
index 00000000000..53b6c3eea5d
Binary files /dev/null and b/assets/img/posting_imgs/proxy.png differ
diff --git a/assets/img/posting_imgs/scae.png b/assets/img/posting_imgs/scae.png
new file mode 100644
index 00000000000..777d30cdaf4
Binary files /dev/null and b/assets/img/posting_imgs/scae.png differ
diff --git a/assets/img/posting_imgs/stacking-autoencoder.png b/assets/img/posting_imgs/stacking-autoencoder.png
new file mode 100644
index 00000000000..968cf366c2a
Binary files /dev/null and b/assets/img/posting_imgs/stacking-autoencoder.png differ
diff --git a/assets/img/posting_imgs/swea2115.png b/assets/img/posting_imgs/swea2115.png
new file mode 100644
index 00000000000..1a342ffff89
Binary files /dev/null and b/assets/img/posting_imgs/swea2115.png differ
diff --git a/assets/img/posting_imgs/vm_docker.png b/assets/img/posting_imgs/vm_docker.png
new file mode 100644
index 00000000000..b8274354332
Binary files /dev/null and b/assets/img/posting_imgs/vm_docker.png differ