그래서 공식문서 커리큘럼은 교재 커리큘럼과 똑같이 짜면 안 된다. 공식문서는 “처음부터 끝까지 읽는 책”이 아니라, 개념을 구현 기준으로 검증하는 기준서로 써야 한다.

아래는 2년 동안 공식문서만 기준으로 따라갈 수 있게 만든 커리큘럼이다.

0. 공식문서 커리큘럼의 큰 원칙

공식문서는 세 종류로 나눠서 봐야 한다.

종류 예시 읽는 목적

언어·도구 공식문서 Python, Git, Bash, GCC, CMake, Docker, pytest 실제 개발환경과 자동화의 기준 하드웨어·임베디드 공식문서 STM32H747I-DISCO, STM32CubeH7, ESP-IDF, M5Stack CoreS3, LVGL 실물 보드에서 동작하는 코드의 기준 AI·비전·에이전트 공식문서 OpenCV, Upstage, LangGraph, Pydantic, PyTorch, scikit-learn, DeepStream, YOLO, ONNX Runtime EdgeCanvas/AegisEdge의 지능형 파이프라인 기준

그리고 수학, 자료구조, 운영체제 이론처럼 “벤더 공식문서”가 없는 영역은 MIT OpenCourseWare 같은 대학 공식 공개자료를 공식문서에 준하는 자료로 둔다. MIT 6.006은 알고리즘과 자료구조, MIT 18.06은 선형대수, MIT 18.05는 확률통계, MIT 6.1810은 운영체제 설계와 시스템 프로그래밍을 다룬다.

1. 1~6개월: 기초 단계 공식문서 커리큘럼

목표

이 단계에서는 EdgeCanvas를 바로 만들지 않는다. 목표는 공식문서를 읽고 개발환경, 언어, 빌드, 시스템 기초를 직접 확인하는 능력이다.

기존 커리큘럼에서도 기초 단계의 목표는 리눅스 터미널, Git, Python CLI, C 메모리, 자료구조, 컴퓨터구조·운영체제 기본, 상태머신 구현으로 잡혀 있다.

1개월차: 리눅스 / 터미널 / Git

봐야 할 공식문서

1. Linux man-pages

2. GNU Bash Reference Manual

3. Git 공식 문서 / Pro Git

4. Ubuntu 공식 문서

5. Linux Filesystem Hierarchy 관련 문서

6. SSH 공식 문서 또는 OpenSSH manual

Linux man-pages는 Linux 커널과 C 라이브러리 인터페이스를 사용자 공간 프로그램 관점에서 문서화한다. 따라서 /dev/video0, /dev/ttyUSB0, chmod, open, read, write, fork, exec 같은 시스템 감각을 익히는 데 가장 직접적이다. Git은 Pro Git 공식 온라인 문서에서 Getting Started, Git Basics, Git Branching 등을 체계적으로 제공한다.

읽는 순서

1. Git: Getting Started

2. Git: Git Basics

3. Git: Branching

4. Linux man-pages: ls, chmod, chown, ln, find, grep, tar

5. Linux man-pages: open, read, write, stat, execve, fork

6. Bash: 변수, quoting, redirection, pipe, exit code

7. Ubuntu: package management, users/groups, systemd 기초

EdgeCanvas 연결

EdgeCanvas는 단순 Python 앱이 아니라 Docker, 빌드, 플래시, 카메라 장치, 시리얼 포트, 환경변수, GitHub 배포를 다룬다. 기존 정리에서도 리눅스는 빌드, Docker, 플래시, 서버, 엣지 환경 때문에 EdgeCanvas와 AegisEdge 모두 필수로 분류되어 있다.

실습 산출물

official-docs-lab/ linux/ file_permission.md device_files.md bash_exit_code.md git/ branch_merge_rebase.md scripts/ setup_env.sh check_devices.sh

통과 기준

chmod, chown, ln -s, grep, find를 설명하고 쓸 수 있다.

PATH, .env, shell variable, environment variable 차이를 설명할 수 있다.

Git branch, merge, rebase, tag를 설명할 수 있다.

/dev/video0, /dev/ttyUSB0 같은 장치 파일이 왜 중요한지 설명할 수 있다.

2개월차: Python 공식문서 기반 자동화

봐야 할 공식문서

1. Python Tutorial

2. Python Standard Library

3. venv

4. argparse

5. subprocess

6. logging

7. json

8. pathlib

9. typing

10. pytest Get Started

Python 공식 튜토리얼은 Python 언어와 시스템의 기본 개념을 소개하는 공식 입문 문서이고, 공식 Python 문서는 버전별 문서·튜토리얼·가이드를 제공한다. pytest 공식문서는 빠르게 테스트를 작성하고 실패 이유를 assertion 출력으로 확인하는 흐름을 제공한다.

읽는 순서

1. Python Tutorial: control flow, functions, modules

2. Python Tutorial: classes, errors and exceptions

3. Standard Library: json

4. Standard Library: pathlib

5. Standard Library: subprocess

6. Standard Library: logging

7. venv/pip 사용법

8. pytest Get Started

9. pytest fixtures는 맛보기만

EdgeCanvas 연결

EdgeCanvas의 API 호출, JSON 스키마 처리, 빌드 명령 실행, 로그 수집, Vision-in-the-Loop 실행, LangGraph 노드 구현은 Python 중심이다. 기존 커리큘럼에서도 2개월차는 Python CLI, JSON, subprocess, logging, pytest를 목표로 잡았다.

실습 산출물

edgecanvas-cli/ edgecanvas_cli/ main.py config.py run_command.py logger.py tests/ test_run_command.py examples/ ui_request.json

통과 기준

JSON 파일을 읽고 검증한다.

subprocess.run()으로 gcc --version, cmake --version, python --version을 실행한다.

실행 결과를 JSON 로그로 저장한다.

pytest로 성공/실패 테스트를 10개 이상 만든다.

3개월차: C / GCC / Make 공식문서

봐야 할 공식문서

1. GCC Online Documentation

2. GCC Warning Options

3. GNU Make Manual

4. C library man-pages

5. cppreference는 공식은 아니지만 C/C++ 레퍼런스 보조로만 사용

GCC 공식문서는 GCC가 C, C++, Objective-C, Fortran 등 여러 언어를 위한 컴파일러 컬렉션이라는 점과 옵션·경고·진단 체계를 제공한다. GCC Warning Options 문서는 각 경고가 어떤 옵션으로 제어되는지 설명한다.

읽는 순서

1. GCC: Overall Options

2. GCC: Warning Options

3. GCC: C Dialect Options

4. GCC: Preprocessor Options

5. GCC: Link Options

6. Make manual: target, prerequisite, recipe

7. Linux man-pages: malloc, free, memcpy, memset, fopen, fread, fwrite

EdgeCanvas 연결

EdgeCanvas가 생성할 최종 코드는 Python이 아니라 MCU에서 동작하는 LVGL C 코드와 펌웨어다. 기존 정리에서도 C는 LVGL/MCU 펌웨어의 기반으로 EdgeCanvas 필수도 5로 분류되어 있다.

실습 산출물

c-official-lab/ pointer.c struct_widget.c bit_flags.c Makefile docs/ gcc_warnings.md compile_vs_link.md

통과 기준

-Wall, -Wextra, -Werror를 설명할 수 있다.

컴파일 오류와 링크 오류를 구분한다.

구조체로 LVGL 위젯 비슷한 데이터를 표현한다.

비트 연산으로 레지스터 플래그를 흉내 낸다.

4개월차: 자료구조 / 알고리즘 공식 공개자료

봐야 할 공식 공개자료

1. MIT OCW 6.006 Introduction to Algorithms

2. MIT OCW 6.046J Introduction to Algorithms, 심화 선택

3. Python 공식문서의 data structures 섹션

4. C++ STL reference는 필요 시 보조

MIT 6.006은 계산 문제의 수학적 모델링, 자료구조, 알고리즘 패러다임, 성능 측정과 분석 기법을 다루는 공식 공개강의다.

읽는 순서

1. MIT 6.006: Algorithms and Computation

2. Data Structures and Dynamic Arrays

3. Sets and Sorting

4. Hashing

5. Trees

6. Graph Search

7. Shortest Paths는 맛보기

8. Python 공식문서: list, dict, set, heapq, collections

EdgeCanvas 연결

EdgeCanvas의 UI는 위젯 트리이고, LangGraph는 상태 그래프이며, 빌드·검증 루프는 상태 전이와 큐로 표현된다. 기존 정리에서도 자료구조는 상태머신, 트리, 그래프, 파서 때문에 EdgeCanvas와 AegisEdge 모두 필수로 분류되어 있다.

실습 산출물

ds-algo-lab/ widget_tree.py graph_workflow.py bfs_dfs.py build_retry_queue.py

통과 기준

UI 위젯 트리를 JSON으로 표현한다.

parse → generate → build → verify → fix 상태 그래프를 만든다.

BFS/DFS를 설명하고 구현한다.

retry queue를 만든다.

5개월차: 컴퓨터구조 / ARM Cortex-M / CMSIS / STM32 Reference Manual

봐야 할 공식문서

1. Arm Technical Documentation

2. CMSIS 공식문서

3. CMSIS-Core

4. STM32H747/757 Documentation

5. RM0399 STM32H745/755 and STM32H747/757 Reference Manual

6. STM32H747I-DISCO User Manual

Arm 공식 문서 포털은 Arm IP와 소프트웨어에 대한 기술 문서를 제공한다. CMSIS는 Arm Cortex-M 기반 프로세서에 대한 벤더 독립적 하드웨어 추상화 계층으로 시작했고, CMSIS-Core는 Cortex-M 디바이스의 기본 런타임과 프로세서 코어·주변장치 접근을 제공한다. ST의 STM32H747/757 문서 페이지는 datasheet, errata, RM0399 reference manual 등을 제공한다.

읽는 순서

1. Arm Cortex-M 개요

2. CMSIS-Core overview

3. vector table

4. interrupt / exception

5. memory map

6. STM32H747 datasheet: memory, pinout, package

7. RM0399: RCC, GPIO, DMA, LTDC, I2C, SPI

8. STM32H747I-DISCO User Manual: 보드 구성, LCD, SDRAM, connector

EdgeCanvas 연결

EdgeCanvas는 데이터시트와 레퍼런스 매뉴얼에서 RAM, Flash, 핀맵, 클럭, 디스플레이 인터페이스를 추출해야 한다. 기존 정리에서도 컴퓨터구조는 MCU, 메모리, 레지스터, 인터럽트 때문에 EdgeCanvas 필수도 5로 분류되어 있다.

실습 산출물

architecture-docs/ arm_cortex_m_summary.md cmsis_core_summary.md stm32h747_memory_map.md stm32h747_peripheral_map.json

통과 기준

Flash, SRAM, peripheral register, memory-mapped I/O를 구분한다.

NVIC, SysTick, vector table을 설명한다.

STM32H747의 메모리 맵 일부를 JSON으로 옮긴다.

RM0399에서 GPIO, RCC, LTDC 관련 절을 찾을 수 있다.

6개월차: 운영체제 / 시스템 프로그래밍 / 이산수학

봐야 할 공식 공개자료

1. Linux man-pages

2. MIT OCW 6.1810 Operating System Engineering

3. MIT OCW 6.033 Computer System Engineering

4. MIT OCW 6.042J Mathematics for Computer Science, 선택

5. MIT OCW 6.006 그래프 파트 복습

MIT 6.1810은 운영체제 설계와 구현, 가상메모리, 파일시스템, 스레드, 컨텍스트 스위치, 커널, 인터럽트, 시스템 콜, IPC를 다룬다. MIT 6.033은 소프트웨어·하드웨어 시스템 공학, 복잡성 제어, OS, 네트워크, 보안, fault tolerance, atomicity 등을 다룬다.

읽는 순서

1. Linux man-pages: fork, exec, pipe, select, poll

2. Linux man-pages: file descriptor, process, signal

3. MIT 6.1810: OS 개요

4. MIT 6.1810: system call, process, virtual memory

5. MIT 6.033: modularity, client/server, naming, reliability

6. 상태기계와 그래프 복습

EdgeCanvas 연결

EdgeCanvas는 Python에서 외부 빌드 명령을 실행하고, 카메라 장치와 시리얼 포트를 열고, Docker에서 재현 가능한 환경을 만들어야 한다. 운영체제 개념이 없으면 “왜 권한 오류가 나는지”, “왜 장치 파일이 안 보이는지”, “왜 subprocess가 실패했는지”를 이해하기 어렵다.

실습 산출물

os-system-lab/ process_subprocess.md device_file_camera.md file_descriptor_demo.py state_machine_theory.md

통과 기준

process, thread, file descriptor, system call을 설명한다.

/dev/video0 권한 문제를 해결하는 절차를 문서화한다.

상태와 전이를 이용해 EdgeCanvas workflow를 설명한다.

2. 7~12개월: 기본 단계 공식문서 커리큘럼

목표

이 단계는 실물 보드에 HMI를 띄우고, 카메라로 검증하는 능력을 만든다. 기존 2년 커리큘럼에서도 기본 단계 목표는 디지털논리, 임베디드, STM32, M5Stack, ESP-IDF, LVGL, CMake, OpenCV를 통해 실물 보드에 HMI를 띄우고 카메라로 검증하는 능력으로 정리되어 있다.

7개월차: 디지털논리 / GPIO / 통신버스 / 보드 회로도

봐야 할 공식문서

1. STM32H747I-DISCO User Manual

2. STM32H747I-DISCO schematic

3. STM32H747/757 datasheet

4. RM0399 reference manual

5. M5Stack CoreS3 schematic / docs

6. ESP32-S3 datasheet / technical reference manual

STM32H747I-DISCO User Manual은 이 보드를 Arm Cortex-M7/M4 dual-core 기반 STM32H747XIH6 개발 플랫폼으로 설명한다. M5Stack CoreS3 공식 문서는 CoreS3 장치와 플래시/개발 절차를 설명한다.

읽는 순서

1. STM32H747I-DISCO block diagram

2. power tree

3. LCD connector

4. SDRAM 연결

5. touch interface

6. USB/ST-LINK 연결

7. M5Stack CoreS3 hardware overview

8. ESP32-S3 pin / flash / PSRAM 구조

9. I2C, SPI, UART, GPIO 관련 절

EdgeCanvas 연결

EdgeCanvas가 보드 프로필을 자동화하려면 단순히 “STM32 보드”라고 알면 안 된다. LCD가 어떤 인터페이스인지, framebuffer가 어디에 있어야 하는지, touch가 I2C인지 SPI인지, 플래시는 어떤 도구로 하는지 알아야 한다.

실습 산출물

board-profiles/ stm32h747i_disco.hardware.md m5stack_cores3.hardware.md interfaces/ gpio.md i2c.md spi.md uart.md

통과 기준

STM32H747I-DISCO의 LCD, touch, SDRAM 연결을 설명한다.

M5Stack CoreS3의 LCD, touch, camera, flash, PSRAM 정보를 정리한다.

보드 프로필 JSON 초안을 만든다.

8개월차: STM32CubeH7 / HAL / LL / BSP / STM32CubeProgrammer

봐야 할 공식문서

1. STM32CubeH7 Product Page

2. STM32CubeH7 GitHub

3. UM2217 STM32H7 HAL and LL drivers

4. STM32H747I-DISCO BSP repository

5. STM32CubeProgrammer

6. STM32CubeProgrammer User Manual

STM32CubeH7는 STM32H7 MCU 애플리케이션 개발에 필요한 임베디드 소프트웨어 구성요소를 하나의 패키지로 제공하고, STM32CubeH7 GitHub에는 CMSIS, HAL/LL 드라이버, BSP, 미들웨어와 예제가 포함된다. STM32CubeProgrammer는 GUI와 CLI 버전으로 제공되며, 프로그래밍 자동화와 스크립팅을 지원한다.

읽는 순서

1. STM32CubeH7 package overview

2. HAL vs LL 구조

3. BSP drivers

4. STM32H747I-DISCO examples

5. GPIO example

6. UART example

7. LCD/BSP example

8. STM32CubeProgrammer CLI

9. Flash, erase, verify, reset

EdgeCanvas 연결

EdgeCanvas가 생성한 C 코드는 단독으로 보드에서 돌지 않는다. BSP, clock, SDRAM, LCD init, linker script, startup code가 맞아야 한다. 기존 정리에서도 단순 C 코드가 아니라 보드 초기화, 클럭, SDRAM, LCD controller, touch, linker script, flash layout까지 맞아야 한다고 정리했다.

실습 산출물

stm32-official-lab/ cubeh7_examples.md hal_ll_bsp_summary.md stm32_flash_cli.md generated_board_profile_stm32h747i_disco.json

통과 기준

HAL, LL, BSP 차이를 설명한다.

STM32CubeProgrammer CLI 명령 구조를 설명한다.

STM32H747I-DISCO LCD 예제가 어디 있는지 찾는다.

플래시 자동화 dry-run 절차를 문서화한다.

9개월차: ESP-IDF / M5Stack CoreS3 / esp_lvgl_port

봐야 할 공식문서

1. ESP-IDF Get Started

2. ESP-IDF Build System

3. ESP-IDF Build / Flash / Monitor

4. M5Stack CoreS3 official docs

5. M5Stack ESP-IDF Development Tutorial

6. esp_lvgl_port

7. ESP Component Registry

ESP-IDF Get Started 문서는 ESP-IDF 앱을 개발, 빌드, 플래시, 모니터링하는 흐름을 안내한다. ESP-IDF는 idf.py -p PORT flash monitor처럼 빌드·플래시·모니터링을 하나의 흐름으로 수행할 수 있다. Espressif의 esp_lvgl_port는 LVGL을 Espressif LCD와 touch driver와 함께 쓰도록 돕는 컴포넌트다.

읽는 순서

1. ESP-IDF installation

2. Start project

3. idf.py build

4. idf.py flash monitor

5. menuconfig

6. build system overview

7. M5Stack CoreS3 docs

8. M5Stack ESP-IDF tutorial

9. esp_lvgl_port README

10. ESP Component Registry 의존성 관리

EdgeCanvas 연결

STM32와 ESP32-S3는 완전히 다른 빌드·플래시·초기화 흐름을 가진다. EdgeCanvas는 이를 board_profile로 추상화해야 한다. 기존 정리에서도 STM32와 ESP32-S3를 동시에 지원하려면 보드별 빌드·플래시·LVGL 초기화 템플릿을 따로 가져가야 한다고 정리되어 있다.

실습 산출물

esp32-official-lab/ espidf_build_flash.md m5stack_cores3_profile.json esp_lvgl_port_summary.md scripts/ flash_m5stack.sh

통과 기준

idf.py build, idf.py flash, idf.py monitor를 설명한다.

ESP-IDF component dependency 구조를 설명한다.

M5Stack CoreS3용 보드 프로필 JSON을 만든다.

ESP-IDF와 STM32CubeH7 빌드 흐름 차이를 표로 정리한다.

10개월차: LVGL 공식문서 집중

봐야 할 공식문서

1. LVGL Documentation

2. Learn the Basics

3. Displays

4. Input devices

5. Widgets

6. Styles

7. Events

8. Images

9. Fonts

10. Integration: Espressif / STM32 관련 자료

LVGL 공식문서는 디스플레이, 입력 장치, 폰트, drawing, widget, style, event, scrolling 등 LVGL의 핵심 모듈을 다룬다. LVGL의 기본 흐름은 driver 초기화, lv_init(), display/input device 생성, UI 생성, lv_timer_handler() 반복 호출로 설명된다.

읽는 순서

1. LVGL 개요

2. Learn the Basics

3. lv_init()

4. display driver

5. input device

6. screen

7. label

8. button

9. image

10. style

11. event

12. timer

13. image converter

14. memory / color depth

15. ESP32 IDF integration

EdgeCanvas 연결

EdgeCanvas의 산출물은 LVGL 초기화 루틴, 위젯 트리, 이벤트 핸들러 C 코드, UI 에셋 C 배열이다. 기존 정리에서도 LVGL은 최신 한국어 단행본보다 공식문서가 1순위이고, 목표는 JSON으로 표현한 UI를 LVGL C 코드로 바꾸는 내부 규칙을 만드는 것이라고 정리되어 있다.

실습 산출물

lvgl-official-lab/ docs/ lvgl_object_model.md lvgl_event_model.md lvgl_image_pipeline.md schema/ ui_schema.json generator/ json_to_lvgl_c.py generated/ screen_main.c

통과 기준

label, button, image를 C 코드로 생성한다.

style과 event handler를 분리한다.

JSON 위젯 트리를 LVGL C 코드로 변환한다.

이미지 리소스를 LVGL에서 사용할 수 있는 형태로 변환하는 흐름을 설명한다.

11개월차: CMake / Arm GNU Toolchain / OpenOCD / ST-LINK / esptool

봐야 할 공식문서

1. CMake Tutorial

2. CMake latest docs

3. Arm GNU Toolchain

4. GCC docs

5. OpenOCD official docs

6. STM32CubeProgrammer CLI

7. ESP-IDF Flash docs

8. esptool docs

CMake는 소스 코드 빌드를 관리하는 도구이고, CMake Tutorial은 CMake가 해결하는 공통 빌드 시스템 문제를 단계별 예제로 설명한다. Arm GNU Toolchain은 Arm 아키텍처용 C, C++, Assembly 프로그래밍을 위한 오픈소스 도구 모음이다.

읽는 순서

1. CMake tutorial: basic project

2. target, include directory, library

3. build directory와 source directory 분리

4. toolchain file 개념

5. GCC compile/link options

6. Arm GNU Toolchain 설치와 arm-none-eabi-gcc 확인

7. STM32CubeProgrammer CLI

8. ESP-IDF flash monitor

9. OpenOCD 기본 구조

EdgeCanvas 연결

EdgeCanvas의 자가수정 루프는 빌드 실패를 읽고 수정해야 한다. 따라서 컴파일 에러, 링크 에러, 플래시 에러를 구조화해야 한다. 기존 실전 계획에서도 21개월차 목표는 generated C project → build → binary → flash → serial log로 잡혀 있다.

실습 산출물

build-flash-official-lab/ cmake_minimal/ toolchain_arm_none_eabi.cmake parse_gcc_log.py parse_cmake_log.py flash_stm32.md flash_esp32.md

통과 기준

CMake configure, build, install 개념을 설명한다.

cross compile과 native compile 차이를 설명한다.

GCC error/warning을 JSON으로 파싱한다.

STM32와 ESP32 플래시 명령을 추상화한다.

12개월차: OpenCV / Pillow / V4L2 공식문서

봐야 할 공식문서

1. OpenCV Python Tutorials

2. OpenCV VideoCapture

3. OpenCV Contours

4. OpenCV Template Matching

5. OpenCV Camera Calibration

6. Pillow documentation

7. Linux Media / V4L2 documentation

OpenCV Python Tutorials는 이미지 처리, feature detection, video analysis, camera calibration, object detection 등을 다룬다. OpenCV VideoCapture 공식 튜토리얼은 카메라에서 프레임을 캡처하고 cap.read()로 프레임을 읽는 흐름을 설명한다. Contours 문서는 threshold 후 contour를 찾아 shape analysis와 object detection에 활용하는 방식을 설명한다. Template Matching은 template image 위치를 큰 이미지에서 찾는 방법이다. Pillow는 Python 이미지 처리 기능을 제공하는 라이브러리로, 파일 포맷 지원과 이미지 처리 기능을 제공한다.

읽는 순서

1. OpenCV image basics

2. VideoCapture

3. color conversion

4. threshold

5. contour

6. template matching

7. image resize / crop

8. camera calibration 맛보기

9. Pillow Image module

10. V4L2 device 개념

EdgeCanvas 연결

EdgeCanvas의 Vision-in-the-Loop는 고급 자율주행 비전이 아니라 LCD 화면이 요구사항대로 떴는지 검증하는 테스트 자동화다. 기존 정리에서도 OpenCV는 Vision-in-the-Loop 검증과 AegisEdge 영상분석 양쪽에 핵심으로 분류되어 있다.

실습 산출물

vision-official-lab/ capture_camera.py detect_screen_region.py compare_template.py compare_color.py vision_report.json

통과 기준

USB 카메라에서 프레임을 읽는다.

LCD 영역을 crop한다.

기준 이미지와 template matching을 수행한다.

화면 검은색/흰색 죽음 상태를 감지한다.

PASS/FAIL 리포트를 만든다.

3. 13~18개월: 심화 단계 공식문서 커리큘럼

목표

이 단계에서는 문서 이해와 자가수정 Agent 설계 능력을 만든다. 기존 커리큘럼에서도 심화 단계는 선형대수, 확률통계, ML/DL, NLP, RAG, Upstage 문서 AI, LangGraph, 네트워크, Docker, 보안을 다루는 단계로 되어 있다.

13개월차: 선형대수 / 확률통계 / 평가 공식 공개자료

봐야 할 공식 공개자료

1. MIT OCW 18.06 Linear Algebra

2. MIT OCW 18.05 Introduction to Probability and Statistics

3. scikit-learn Model Evaluation

4. OpenCV camera geometry 관련 문서

MIT 18.06은 행렬 이론과 선형대수를 다루며, 시스템 방정식, 벡터공간, determinant, eigenvalue 등을 포함한다. MIT 18.05는 조합론, 확률변수, 확률분포, Bayesian inference, hypothesis testing, confidence interval, linear regression 등을 다룬다. scikit-learn은 모델 fitting, preprocessing, model selection, evaluation 등을 제공하는 머신러닝 라이브러리다.

읽는 순서

1. MIT 18.06: vectors, matrices

2. matrix multiplication

3. least squares

4. eigenvalues

5. MIT 18.05: probability, random variables

6. conditional probability

7. Bayesian inference

8. hypothesis testing

9. scikit-learn metrics

10. confusion matrix, precision, recall

EdgeCanvas 연결

Vision-in-the-Loop의 판정 일치율, 색상/위치 오차, threshold, 평가 지표, AegisEdge 객체탐지 평가에 필요하다. 기존 커리큘럼도 이 연결을 명시하고 있다.

실습 산출물

math-evaluation-lab/ pixel_error_metric.py confusion_matrix_for_vision.py pass_fail_statistics.ipynb

통과 기준

PASS/FAIL 100개 결과로 accuracy, precision, recall을 계산한다.

UI 요소 위치 오차를 픽셀 단위로 계산한다.

threshold를 바꾸면 FP/FN이 어떻게 변하는지 설명한다.

14개월차: 머신러닝 / 딥러닝 공식문서

봐야 할 공식문서

1. scikit-learn Getting Started

2. scikit-learn User Guide

3. scikit-learn Model Selection and Evaluation

4. PyTorch 60 Minute Blitz

5. PyTorch Learn the Basics

scikit-learn 공식문서는 supervised/unsupervised learning, model selection, model evaluation 등을 체계적으로 제공한다. PyTorch 60 Minute Blitz는 tensor, autograd, neural network, image classifier 학습을 목표로 하는 공식 튜토리얼이다.

읽는 순서

1. scikit-learn getting started

2. train/test split

3. preprocessing

4. model evaluation

5. classification metrics

6. PyTorch tensors

7. autograd

8. neural networks

9. image classifier

10. inference mode

EdgeCanvas 연결

EdgeCanvas는 모델을 직접 학습하지 않아도 되지만, Vision 판정과 AegisEdge 객체탐지를 평가하려면 ML/DL의 기본을 알아야 한다. AegisEdge가 YOLO/ONNX/DeepStream으로 확장되면 필수다.

실습 산출물

ml-official-lab/ sklearn_classifier.py pytorch_image_classifier.py evaluation.md

통과 기준

train/validation/test를 구분한다.

overfitting을 설명한다.

작은 이미지 분류 모델을 학습한다.

평가 지표를 정리한다.

15개월차: Transformer / NLP / RAG 공식문서

봐야 할 공식문서

1. Hugging Face Documentation

2. Hugging Face LLM Course

3. Transformers documentation

4. Tokenizers documentation

5. Datasets documentation

6. LangChain text splitters / retrievers, 필요 시

Hugging Face LLM Course는 LLM과 NLP를 Transformers, Datasets, Tokenizers, Accelerate, Hub 생태계와 함께 학습하도록 구성되어 있다. Transformers 문서는 transformer model의 기본부터 다양한 task 응용까지 안내한다.

읽는 순서

1. LLM Course chapter 1

2. tokenization

3. transformer pipeline

4. embeddings

5. datasets

6. chunking 개념

7. retrieval 개념

8. structured output 개념

9. RAG 실패 유형 정리

10. prompt injection 기초

EdgeCanvas 연결

EdgeCanvas의 데이터시트 해석은 문서 이해 문제다. 기존 실전 계획도 데이터시트 PDF/Markdown → Document Parse → Information Extract → MCU hardware schema → validation report를 첫 MVP로 둔다.

실습 산출물

rag-official-lab/ split_datasheet_markdown.py simple_retrieval.py structured_extraction_schema.py extraction_failure_cases.md

통과 기준

문서를 chunk로 나눈다.

retrieval 결과를 근거와 함께 출력한다.

JSON structured output을 검증한다.

hallucination과 extraction error를 구분한다.

16개월차: Upstage Document AI / Solar / VARCO 공식문서

봐야 할 공식문서

1. Upstage Document Parse API

2. Upstage Information Extract

3. Upstage Universal Information Extraction

4. Upstage Solar API / Console docs

5. Upstage Cookbook

6. NC AI / VARCO API Platform

7. NC AI VARCO Art 관련 공식 페이지

Upstage Document Parse API는 복잡한 문서를 구조화된 HTML 또는 Markdown으로 파싱한다고 설명되어 있다. Upstage Information Extract는 scanned images, PDFs, Office files, rotated pages, 500+ page documents 등 다양한 문서에서 데이터 추출을 지원한다고 설명한다. Universal Information Extraction API는 템플릿이나 재학습 없이 구조화 데이터를 추출하는 API로 설명된다. NC AI 공식 페이지는 VARCO를 콘텐츠 워크플로우를 통합하는 차세대 AI 엔진으로 소개한다.

읽는 순서

1. Document Parse overview

2. Document Parse API request/response

3. output format: HTML / Markdown

4. Information Extract overview

5. Universal IE schema 설계

6. error handling

7. API key 관리

8. rate limit / retry 설계

9. Solar API

10. VARCO API / VARCO Art 가능 범위 확인

EdgeCanvas 연결

구현제안서상 EdgeCanvas는 Document Parse와 Information Extract로 레지스터 맵, 핀맵, 클럭 트리, 타이밍 제약을 JSON 스키마로 추출한다. 기존 정리에서도 MCU 데이터시트 전체를 읽는 것이 아니라 필요한 정보만 안정적으로 뽑아야 한다고 정리되어 있다.

실습 산출물

upstage-official-lab/ parse_datasheet.py extract_mcu_schema.py schemas/ mcu_schema.json board_profile_schema.json reports/ extraction_quality_report.md

통과 기준

데이터시트 1개를 Markdown/HTML로 변환한다.

MCU 관련 필드 10개 이상을 JSON으로 추출한다.

Pydantic validation을 통과한다.

사람이 검토한 정답과 차이를 기록한다.

17개월차: LangGraph / LangChain / Pydantic 공식문서

봐야 할 공식문서

1. LangGraph Overview

2. LangGraph Graph API

3. StateGraph

4. Nodes and Edges

5. Conditional Edges

6. Persistence / Checkpointing

7. Human-in-the-loop

8. LangChain Tools

9. Pydantic Models

10. Pydantic Validators

LangGraph Graph API 문서는 nodes와 edges를 조합해 상태가 시간에 따라 진화하는 복잡하고 반복적인 workflow를 만들 수 있다고 설명한다. LangChain tools 문서는 tool을 모델이 호출할 수 있는 유틸리티로 설명하고, tool 입력은 모델이 생성하고 출력은 다시 모델에 전달되는 구조라고 설명한다. Pydantic은 Python에서 가장 널리 사용되는 데이터 검증 라이브러리라고 공식문서가 설명하며, model validation은 지정된 type과 constraint에 맞는 model instance를 만드는 과정으로 설명된다.

읽는 순서

1. LangGraph overview

2. Graph API

3. StateGraph

4. nodes

5. edges

6. conditional routing

7. retry loop

8. persistence/checkpointing

9. human-in-the-loop

10. LangChain tools

11. Pydantic models

12. Pydantic validators

EdgeCanvas 연결

EdgeCanvas의 핵심은 LangGraph 상태머신 기반 self-healing agent다. 기존 정리에서도 LangGraph는 입력 수신부터 실기 검증까지 전 구간을 상태머신으로 제어하고, 실패 시 코드 생성 단계로 재진입하는 자가수정 루프를 실행하는 구조로 정리되어 있다.

실습 산출물

langgraph-official-lab/ state.py graph.py nodes/ parse_datasheet.py extract_schema.py generate_lvgl.py build.py verify.py fix.py schemas/ workflow_state.py

통과 기준

parse → extract → generate → build → verify → fix 루프를 mock으로 구현한다.

조건부 edge로 PASS/FAIL 분기를 만든다.

Pydantic으로 state schema를 검증한다.

실패 시 최대 retry 횟수를 제한한다.

18개월차: Docker / GitHub Actions / 보안 공식문서

봐야 할 공식문서

1. Docker Get Started

2. Dockerfile docs

3. Docker Compose

4. GitHub Actions docs

5. pytest fixtures

6. OWASP Top 10

7. KISA / KrCERT 보안 가이드

8. Python dependency 보안 관련 공식자료

9. GitHub secret scanning / Actions secrets

Docker 공식문서는 Docker를 시작하는 데 필요한 자료를 제공하고, Dockerfile은 컨테이너 이미지를 만들기 위한 text-based document라고 설명한다. Docker Compose는 여러 컨테이너 애플리케이션을 정의하고 실행하는 도구로 설명된다. GitHub Actions 공식문서는 CI/CD를 포함한 workflow를 저장소에서 자동화할 수 있다고 설명한다. OWASP Top 10은 웹 애플리케이션 보안을 위한 표준 awareness document로 설명된다.

읽는 순서

1. Docker overview

2. Dockerfile 작성

3. image build

4. container run

5. volume

6. compose

7. GitHub Actions quickstart

8. workflow syntax

9. secrets

10. pytest fixtures

11. OWASP Top 10

12. KISA 보안 가이드

13. command injection / path traversal / secret leakage 체크리스트

EdgeCanvas 연결

EdgeCanvas는 외부 PDF 입력, 코드 생성, 파일 쓰기, 빌드 실행, API 키 사용을 모두 수행한다. 즉 보안은 나중 문제가 아니라 architecture 단계에서 들어가야 한다. 기존 정리에서도 보안은 API 키, 코드 생성, 외부 문서 입력 때문에 EdgeCanvas 필수도 4로 분류되어 있다.

실습 산출물

deployment-security-official-lab/ Dockerfile docker-compose.yml .github/workflows/test.yml .env.example security_checklist.md safe_subprocess.py

통과 기준

Docker로 동일한 CLI가 재현 실행된다.

GitHub Actions에서 pytest가 돈다.

API key를 코드에 하드코딩하지 않는다.

외부 명령 실행은 allowlist로 제한한다.

보안 체크리스트를 만든다.

4. 19~24개월: 실전 단계 공식문서 커리큘럼

목표

이 단계에서는 공식문서를 “읽는 것”이 아니라 필요한 공식문서로 돌아가며 EdgeCanvas MVP를 완성한다. 기존 실전 단계 목표도 EdgeCanvas MVP, AegisEdge 확장 프로토타입, 기술문서, 포트폴리오로 잡혀 있다.

19개월차: 데이터시트 → JSON

기준 공식문서

Upstage Document Parse

Upstage Information Extract

Universal Information Extraction

Pydantic Models / Validators

STM32H747/757 datasheet

RM0399 Reference Manual

M5Stack CoreS3 docs

ESP32-S3 technical reference

구현 목표

PDF / Markdown / HTML → Document Parse → Information Extract → Pydantic validation → MCU hardware schema

반드시 확인할 공식문서 포인트

Upstage API request/response

output format

schema extraction

validation error

STM32 memory / pin / clock / peripheral

M5Stack flash / PSRAM / display / camera

ESP-IDF target information

산출물

edgecanvas/ parsers/ schemas/ board_profiles/ stm32h747i_disco.json m5stack_cores3.json reports/ extraction_report.md

20개월차: JSON → LVGL C 코드

기준 공식문서

LVGL Learn the Basics

LVGL Widgets

LVGL Styles

LVGL Events

LVGL Images

LVGL Display/Input device

CMake

GCC

구현 목표

UI requirement → UI schema → LVGL widget tree → C source generation

반드시 확인할 공식문서 포인트

lv_init()

display creation

input device

label/button/image API

style API

event callback

image data

lv_timer_handler()

산출물

edgecanvas/ ui_schema/ generators/ lvgl_c_generator.py templates/ generated/ dashboard.c

21개월차: 빌드 / 플래시 자동화

기준 공식문서

CMake Tutorial

Arm GNU Toolchain

GCC docs

STM32CubeH7

STM32CubeProgrammer CLI

ESP-IDF Build / Flash / Monitor

esptool

OpenOCD

구현 목표

generated C project → build → parse error → flash → serial log

반드시 확인할 공식문서 포인트

CMake configure/build

cross compile toolchain file

include path

link error

map file

STM32 flash CLI

ESP-IDF flash monitor

산출물

edgecanvas/ builders/ cmake_builder.py espidf_builder.py flashers/ stm32_cubeprogrammer.py espidf_flasher.py logs/

22개월차: Vision-in-the-Loop

기준 공식문서

OpenCV VideoCapture

OpenCV threshold

OpenCV contours

OpenCV template matching

Pillow Image

V4L2 docs

구현 목표

camera → LCD region crop → expected UI comparison → PASS/FAIL → report

반드시 확인할 공식문서 포인트

cv.VideoCapture

cap.isOpened()

cap.read()

cv.cvtColor

cv.threshold

cv.findContours

cv.matchTemplate

crop/resize

color comparison

산출물

edgecanvas/ vision/ capture.py lcd_region.py compare_layout.py compare_color.py report.py

23개월차: LangGraph Self-Healing 통합

기준 공식문서

LangGraph Graph API

conditional edges

persistence/checkpoint

LangChain tools

Pydantic validators

pytest fixtures

Docker

GitHub Actions

구현 목표

extract schema → generate code → build → flash → verify → failed? → fix → retry → report

반드시 확인할 공식문서 포인트

state schema

node function

edge

conditional routing

retry count

checkpoint

tool execution

build evaluator

vision evaluator

산출물

edgecanvas/ graph/ state.py workflow.py conditions.py evaluators/ fixers/ tests/

24개월차: 통합 / 문서화 / AegisEdge 확장

기준 공식문서

EdgeCanvas 통합:

Docker

GitHub Actions

pytest

CMake

LVGL

STM32CubeH7

ESP-IDF

Upstage

LangGraph

OpenCV

AegisEdge 영상분석 확장:

NVIDIA DeepStream

Ultralytics YOLO11

ONNX Runtime

OpenCV

Docker

DeepStream은 USB/CSI camera, video file, RTSP stream을 입력으로 받아 AI와 computer vision으로 환경 이해를 위한 insight를 생성하는 streaming analytics toolkit이다. Ultralytics YOLO11 문서는 object detection, segmentation, classification, pose 등 작업과 train/predict/export 흐름을 제공한다. ONNX는 머신러닝 모델을 표현하기 위한 open format이고, ONNX Runtime은 다양한 기술 스택에서 inference를 가속하는 production-grade AI engine으로 설명된다.

산출물

edgecanvas/ README.md docs/ architecture.md official_docs_map.md board_profile.md security.md benchmark.md examples/ stm32_demo/ m5stack_demo/ docker/ tests/ reports/

aegisedge-prototype/ capture/ inference/ events/ api/ dashboard/

5. AegisEdge 선택 심화 공식문서 트랙

AegisEdge 명세는 아직 별도로 확인되지 않았으므로, 여기서는 엣지 AI / 영상분석 / 카메라 기반 이벤트 추론으로 가정한다. AegisEdge가 실제로 다른 구조라면 이 트랙은 조정해야 한다.

영상분석 트랙

공식문서 순서

1. OpenCV Python Tutorials

2. Ultralytics YOLO11

3. Ultralytics Predict

4. Ultralytics Export

5. ONNX

6. ONNX Runtime

7. NVIDIA DeepStream Overview

8. DeepStream reference app

9. Docker

10. GitHub Actions

목표

USB/RTSP camera → OpenCV preprocessing → YOLO inference → ONNX export → DeepStream pipeline → event JSON → Docker deployment

DeepStream reference application은 GStreamer 기반이며 camera, RTSP input, encoded file input, multi stream/source를 지원한다고 공식문서가 설명한다.

로봇 연동 트랙

ROS2는 EdgeCanvas 본체의 1순위는 아니다. 기존 정리에서도 ROS2는 AegisEdge가 로봇과 연결되거나 EdgeCanvas가 서비스 로봇 HMI와 연동될 때 학습하는 후순위로 분리했다.

공식문서 순서

1. ROS 2 Concepts

2. Nodes

3. Topics

4. Services

5. Actions

6. Parameters

7. tf2

8. Gazebo ROS integration

9. Nav2, 실제 이동로봇 필요 시

10. Isaac ROS / Isaac Sim, NVIDIA 로봇비전 필요 시

ROS2 공식문서는 topic, service, action이 노드 간 데이터 교환 인터페이스라고 설명하고, service는 synchronous request/response, action은 feedback을 포함하는 long-running task에 적합하다고 설명한다. Gazebo 문서는 ROS와 Gazebo 버전 조합을 안내하고, ROS2와 Gazebo가 서로 데이터를 주고받도록 연동할 수 있음을 설명한다.

멀티에이전트 / 도구연동 트랙

공식문서 순서

1. LangGraph

2. LangChain Tools

3. Pydantic

4. MCP official docs

5. A2A official docs, 필요 시

6. OWASP Top 10

7. GitHub Actions secrets

8. Docker security

이 트랙은 대회 초기 구현보다 후속 제품화에 가깝다. EdgeCanvas 대회 구현은 먼저 데이터시트 → LVGL → 빌드 → 플래시 → Vision 검증을 완성해야 한다.

6. 공식문서 전체 우선순위표

우선순위 공식문서 왜 보는가 단계

1 Python docs Agent, API, 자동화, subprocess 기초 2 Git / Pro Git 버전관리, 협업, 포트폴리오 기초 3 Linux man-pages 장치파일, 프로세스, 시스템콜 기초 4 GCC / Make C 컴파일, warning, 빌드 오류 기초 5 MIT 6.006 자료구조, 그래프, 상태머신 기초 6 Arm / CMSIS Cortex-M, 인터럽트, 메모리맵 기초기본 7 STM32H747I-DISCO / RM0399 실제 타깃 보드 기준 기본 8 STM32CubeH7 / HAL / BSP 보드 초기화와 드라이버 기본 9 ESP-IDF / M5Stack CoreS3 휴대 타깃 보드 기준 기본 10 LVGL HMI 자동생성의 핵심 기본 11 CMake / Arm GNU Toolchain 펌웨어 빌드 자동화 기본 12 OpenCV / Pillow / V4L2 Vision-in-the-Loop 기본 13 MIT 18.06 / 18.05 비전·AI 평가 수학 심화 14 scikit-learn / PyTorch ML/DL 기본과 평가 심화 15 Hugging Face docs Transformer/RAG 이해 심화 16 Upstage docs 데이터시트 문서 AI 심화실전 17 LangGraph / Pydantic Self-Healing 상태머신 심화실전 18 Docker / GitHub Actions / pytest 재현성, 테스트, 제출 심화실전 19 OWASP / KISA API 키, 코드생성 보안 심화~실전 20 DeepStream / YOLO / ONNX AegisEdge 영상분석 선택 심화 21 ROS2 / Gazebo 로봇 연동 선택 심화

7. 주간 공식문서 공부법

공식문서는 “읽었다”가 아니라 “구현 기준으로 바꿨다”가 중요하다.

매주 반복 루틴

요일 할 일

월 공식문서의 개요/Getting Started 읽기 화 API reference에서 함수·명령어·옵션 확인 수 최소 예제 실행 목 예제를 EdgeCanvas 구조에 맞게 변형 금 실패 로그 정리 토 README / notes 작성 일 다음 주 공식문서 목록 갱신

문서 읽을 때 항상 남길 것

docs-notes/ source_name.md version.md why_needed.md commands.md api_summary.md edgecanvas_mapping.md failure_cases.md

각 공식문서마다 아래 질문에 답해야 한다.

1. 이 문서는 EdgeCanvas 어느 모듈과 연결되는가?

2. 구현에서 직접 쓰는 함수/명령어/API는 무엇인가?

3. 실패할 때 어떤 에러가 나는가?

4. 버전 의존성이 있는가?

5. 내 코드에 어떤 schema나 wrapper로 반영할 것인가?

8. 공식문서 기준 최종 2년 로드맵 요약

기초, 1~6개월

Linux man-pages → Git / Pro Git → Python docs → pytest → GCC / Make → MIT 6.006 → Arm / CMSIS → MIT 6.1810

목표는 개발환경, 언어, 자료구조, 시스템 기초다.

기본, 7~12개월

STM32H747I-DISCO → RM0399 → STM32CubeH7 → STM32CubeProgrammer → ESP-IDF → M5Stack CoreS3 → LVGL → CMake → OpenCV

목표는 실물 보드에 HMI를 띄우고 카메라로 검증하는 것이다.

심화, 13~18개월

MIT 18.06 / 18.05 → scikit-learn → PyTorch → Hugging Face → Upstage Document Parse → Upstage Information Extract → LangGraph → Pydantic → Docker → GitHub Actions → OWASP / KISA

목표는 문서 이해, 평가, 자가수정 에이전트, 배포, 보안이다.

실전, 19~24개월

Upstage + Pydantic → LVGL generator → CMake / STM32 / ESP-IDF build → OpenCV Vision-in-the-Loop → LangGraph Self-Healing → Docker / GitHub Actions → AegisEdge optional track

목표는 데이터시트 → JSON → LVGL C 코드 → 빌드 → 플래시 → 카메라 검증 → 자가수정 리포트다. 이 목표는 기존 2년 커리큘럼의 최종 요약과도 일치한다.

9. 가장 먼저 봐야 할 공식문서 10개

지금 바로 시작한다면 순서는 이게 가장 현실적이다.

1. Python Tutorial

2. Git / Pro Git

3. Linux man-pages

4. GCC Warning Options

5. MIT 6.006 Introduction to Algorithms

6. Arm CMSIS-Core

7. STM32H747I-DISCO User Manual

8. ESP-IDF Get Started

9. LVGL Learn the Basics

10. OpenCV VideoCapture + Contours + Template Matching

그다음에:

11. CMake Tutorial

12. STM32CubeH7 / HAL / BSP

13. M5Stack CoreS3 docs

14. Upstage Document Parse / Information Extract

15. LangGraph Graph API

16. Pydantic Models / Validators

17. Dockerfile / Docker Compose

18. GitHub Actions

19. OWASP Top 10 / KISA

20. DeepStream / YOLO / ONNX Runtime, AegisEdge 영상분석 시

최종적으로 말하면, 공식문서 기준 커리큘럼의 중심축은 LVGL이나 LangGraph 하나가 아니라 “공식문서로 검증 가능한 파이프라인”이다. 즉, Linux/Python/C/GCC로 개발환경을 만들고, Arm/STM32/ESP-IDF/LVGL로 실물 HMI를 만들고, OpenCV로 검증하고, Upstage/LangGraph/Pydantic으로 문서 이해와 자가수정 루프를 만들고, Docker/GitHub Actions/OWASP로 재현성과 보안을 확보하는 순서가 가장 객관적으로 맞다.

AegisEdge는 별도 명세 문서가 아직 없으므로, 여기서는 이전 정리와 네 맥락에 맞춰 엣지 AI, 영상분석, 카메라 기반 추론, 보안·정책·이벤트 처리형 에이전트로 확장된다고 가정한다. 따라서 ROS2·SLAM·로보틱스는 “주전공”이 아니라 후반 선택 심화 트랙으로 둔다.

0. 커리큘럼 설계 원칙

이 커리큘럼은 다음 세 가지 근거로 설계했다.

첫째, EdgeCanvas 구현제안서의 기술스택이 매우 넓다. 문서에는 Python 3.11 이상, C/C++, CMake, Make, Bash, LangGraph, LangChain, Pydantic, LVGL 9.x, arm-none-eabi-gcc, ESP-IDF v5.x, ST-Link, esptool, OpenOCD, pyserial, OpenCV, Pillow, v4l2, pytest, Docker, pip, GitHub, requirements.txt, CMakeLists.txt가 들어 있다. 즉, 단순히 LLM API만 쓰는 수준이 아니라 실제 펌웨어 빌드·플래시·비전 검증·배포까지 이해해야 한다.

둘째, EdgeCanvas의 핵심 루프는 문서 이해 → 하드웨어 제약 추출 → LVGL 코드 생성 → 빌드 → 플래시 → 카메라 검증 → 실패 시 자가수정이다. 구현제안서에는 Upstage Document Parse/Information Extract로 레지스터 맵·핀맵·클럭 트리·타이밍 제약을 JSON으로 추출하고, Solar Pro 3가 LVGL 초기화 루틴·위젯 트리·이벤트 핸들러 C 코드를 생성하며, USB 카메라 기반 검증과 LangGraph 상태머신 자가수정 루프를 수행한다고 되어 있다.

셋째, 표준 컴퓨터공학 커리큘럼 관점에서도 이 경로가 타당하다. ACM CS2023의 지식영역에는 알고리즘, 컴퓨터구조, 운영체제, 네트워크, 보안, AI, 데이터관리, HCI, 수학·통계 기초가 포함된다. (csed.acm.org) 컴퓨터공학 CE2016 쪽에서는 회로·전자, 디지털 설계, 컴퓨터구조, 임베디드 시스템, 네트워크, 알고리즘이 핵심 영역으로 제시된다. (ACM)

그래서 2년은 이렇게 나눈다.

1. 2년 후 목표 수준

2년 뒤에는 다음 정도까지 가는 것을 목표로 잡는다.

EdgeCanvas 기준

너는 다음을 혼자 설명하고 구현할 수 있어야 한다.

1. MCU 데이터시트에서 RAM, Flash, 핀맵, 클럭, 디스플레이 인터페이스 정보를 읽는다.
2. 그 정보를 JSON 스키마로 정리한다.
3. UI 요구사항을 LVGL 위젯 트리로 바꾼다.
4. LVGL C 코드를 생성한다.
5. STM32H747I-DISCO 또는 M5Stack CoreS3에서 빌드·플래시한다.
6. USB 카메라로 화면을 촬영한다.
7. OpenCV 또는 멀티모달 모델로 화면을 검증한다.
8. 실패하면 LangGraph 상태머신이 수정 루프로 되돌아간다.
9. Docker, pytest, GitHub Actions로 재현 가능한 패키지를 만든다.

이 목표는 구현제안서의 결과물인 타깃 MCU별 LVGL C 소스 프로젝트, 크로스 컴파일 펌웨어 바이너리, UI 에셋 C 배열, Vision-in-the-Loop 검증 리포트 번들과 직접 연결된다.

AegisEdge 기준

AegisEdge가 영상분석·엣지 AI 방향이라면 다음을 목표로 잡는다.

1. USB/RTSP 카메라 영상을 받는다.
2. OpenCV로 전처리한다.
3. YOLO 또는 ONNX Runtime으로 객체탐지를 수행한다.
4. 이벤트를 JSON으로 구조화한다.
5. Docker 또는 Jetson 계열 환경에 배포한다.
6. 보안, 로그, API, 관제 대시보드까지 확장 가능한 구조를 만든다.

NVIDIA DeepStream은 실시간 스트리밍 분석 SDK로, 비디오·오디오·이미지 이해와 AI 기반 멀티센서 처리를 위한 툴킷으로 설명된다. 따라서 AegisEdge가 CCTV/RTSP/엣지 비전으로 가면 후반부에 들어가는 것이 타당하다. (NVIDIA Developer)

2. 공부 시간 기준

현실적으로는 아래 세 가지 중 하나를 선택해야 한다.

이 커리큘럼은 주 12~15시간 기준으로 설계한다.

주간 배분은 이렇게 한다.

매달 산출물이 있어야 한다. 책을 읽는 것만으로는 부족하고, 반드시 동작하는 코드, 회로/보드 실험, README, 테스트 결과를 남겨야 한다.

3. 전체 난이도 맵

기초 단계에서 피해야 할 것

처음 6개월 동안은 아래를 깊게 파지 않는다.

• 강화학습
• 휴머노이드
• SLAM
• ROS2 Nav2
• Mobile ALOHA
• 복잡한 LLM 논문
• 멀티에이전트 프레임워크 난립

이유는 명확하다. EdgeCanvas의 첫 병목은 AI 이론이 아니라 리눅스, C, 메모리, 빌드, 임베디드, LVGL, OpenCV 검증이다. 이전 정리 문서에서도 EdgeCanvas를 제대로 이해하려면 C와 메모리, 컴퓨터구조, 임베디드 시스템, LVGL/HMI, OpenCV 기반 화면 검증, LangGraph 상태머신이 핵심이라고 정리했다.

4. 1~6개월: 기초 단계

목표

이 단계의 목적은 “프로그래밍을 해봤다”가 아니라 시스템이 어떻게 돌아가는지 밑바닥 감각을 만드는 것이다.

6개월이 끝나면 다음을 할 수 있어야 한다.

• 리눅스 터미널에서 개발환경을 구축한다.
• Git으로 버전관리한다.
• Python으로 CLI 도구를 만든다.
• C로 포인터, 구조체, 파일 입출력, 메모리 개념을 이해한다.
• 자료구조를 직접 구현한다.
• 컴퓨터구조와 운영체제 기본 용어를 설명한다.
• 간단한 상태머신을 구현한다.

1개월차: 리눅스 / Git / 개발환경

공부할 것

• 리눅스 파일 시스템
• 터미널 명령어
• Bash
• 권한
• 환경변수
• 프로세스
• 패키지 설치
• Git commit / branch / merge
• SSH
• VS Code 또는 Cursor 개발환경

교재

1. 《리눅스 커맨드라인 완벽 입문서》
2. Pro Git 한국어 공식 문서

《리눅스 커맨드라인 완벽 입문서》는 초보 리눅스 사용자를 위한 책으로, 파일·디렉터리·심볼릭 링크 생성과 삭제 등 커맨드라인 기본을 다룬다. (Kyobo Bookstore) Git은 공식 사이트에서 Pro Git 한국어판을 제공하므로 책을 별도로 사지 않아도 된다.

공식문서

• Git 공식 문서
• Ubuntu 공식 문서
• Docker 설치 문서, 단 개념만

실습 산출물

edgecanvas-lab/
  README.md
  scripts/
    setup_env.sh
    hello.sh
  notes/
    linux_commands.md
    git_workflow.md

통과 기준

• git init, commit, branch, merge를 설명할 수 있다.
• .env 파일과 환경변수 차이를 설명할 수 있다.
• Bash 스크립트로 Python 가상환경을 만든다.
• /dev/ttyUSB0, /dev/video0 같은 장치 파일 개념을 이해한다.

2개월차: Python 기초 + 자동화

공부할 것

• 함수
• 클래스
• 모듈
• 가상환경
• pip
• 파일 입출력
• JSON
• argparse 또는 Typer
• subprocess
• 예외 처리
• logging
• pytest 기초

교재

1. 《혼자 공부하는 파이썬》

이 책은 독학으로 Python을 처음 배우는 사람이 필요한 내용을 체계적으로 학습하도록 구성된 입문서로 소개된다. 개정판은 혼공 계획표, 누적 예제, 도전 문제를 포함한다. (한빛+)

공식문서

• Python 공식 튜토리얼
• pytest getting started
• Typer 문서
• Pydantic 문서는 아직 맛보기만

실습 산출물

edgecanvas-cli/
  edgecanvas_cli/
    main.py
    config.py
    logger.py
  tests/
    test_config.py
  data/
    sample_ui_request.json

기능:

edgecanvas parse-request sample_ui_request.json
edgecanvas show-config
edgecanvas run-command "gcc --version"

통과 기준

• JSON 파일을 읽고 검증한다.
• subprocess로 외부 명령어를 실행하고 로그를 남긴다.
• pytest로 최소 10개 테스트를 만든다.

3개월차: C 언어 / 메모리

공부할 것

• 포인터
• 배열
• 문자열
• 구조체
• 헤더 파일
• 전처리기
• static / extern
• bit operation
• stack / heap
• volatile 개념
• 메모리 맵 사고방식

교재

1. 《윤성우의 열혈 C 프로그래밍》

이 책은 C 언어 기본서로 오래 사용되어 온 책이고, 배열·포인터·구조체·매크로 같은 C 입문 핵심을 다룬다. (Aladin)

보조 자료

• C 언어 레퍼런스
• GCC warning 옵션 문서

실습 산출물

c-lab/
  pointer_lab.c
  struct_lab.c
  bitfield_lab.c
  json_like_parser.c
  Makefile

통과 기준

• 포인터와 배열의 차이를 설명한다.
• 구조체 배열을 만든다.
• 비트 연산으로 레지스터 플래그처럼 값을 설정한다.
• gcc -Wall -Wextra 경고를 읽고 수정한다.

4개월차: 자료구조 / 알고리즘 기초

공부할 것

• 배열
• 연결 리스트
• 스택
• 큐
• 해시 테이블
• 트리
• 그래프
• 정렬
• 검색
• BFS / DFS
• 시간복잡도
• 공간복잡도

교재

1. 《C로 배우는 쉬운 자료구조 4판》
2. 보조: 《알고리즘 도감》

《C로 배우는 쉬운 자료구조 4판》은 자료구조 원리와 구현 방법을 C 프로그램으로 차근차근 구현하도록 구성되어 있다. (한빛+)

EdgeCanvas 연결

• LVGL UI는 위젯 트리다.
• LangGraph는 상태 그래프다.
• 빌드·검증 루프는 큐와 상태 전이를 가진다.
• 데이터시트 추출 결과는 JSON 트리다.

실습 산출물

ds-lab/
  stack.c
  queue.c
  tree_widget.c
  graph_state_machine.c

graph_state_machine.c는 다음 상태를 가져야 한다.

PARSE_DOC
→ EXTRACT_SCHEMA
→ GENERATE_CODE
→ BUILD
→ FLASH
→ VERIFY
→ FIX_OR_DONE

통과 기준

• 트리와 그래프 차이를 설명한다.
• DFS/BFS를 직접 구현한다.
• 간단한 상태머신을 C 또는 Python으로 구현한다.

5개월차: 컴퓨터구조

공부할 것

• CPU
• 레지스터
• 명령어
• 메모리 계층
• 캐시
• 버스
• 인터럽트
• DMA
• memory-mapped I/O
• endian
• stack frame
• startup code
• linker 개념

교재

1. 《컴퓨터 구조 및 설계 ARM》
2. 보조: STM32H747I-DISCO User Manual 일부

Patterson & Hennessy의 《컴퓨터 구조 및 설계》는 하드웨어와 소프트웨어 사이의 상호작용을 이해하기 위한 대표적인 컴퓨터구조 교재이며, ARM 번역판도 확인된다. (Yes24)

EdgeCanvas 연결

EdgeCanvas는 MCU 데이터시트를 읽어야 한다. 따라서 레지스터, 메모리 맵, 인터럽트, DMA, 버스 개념을 모르면 데이터시트 기반 코드 생성이 껍데기만 된다.

실습 산출물

architecture-notes/
  memory_map.md
  interrupt.md
  stack_heap.md
  stm32h747_memory_summary.md

통과 기준

• RAM, Flash, Register, Peripheral, Memory-mapped I/O 차이를 설명한다.
• MCU 데이터시트에서 메모리 맵 표를 보고 의미를 설명한다.
• stack overflow와 heap fragmentation 개념을 설명한다.

6개월차: 운영체제 + 이산수학 입문

공부할 것

운영체제:

• 프로세스
• 스레드
• 파일 시스템
• 장치 파일
• 권한
• system call
• I/O
• 동기화

이산수학:

• 명제논리
• 집합
• 관계
• 함수
• 그래프
• 트리
• 귀납법
• 상태기계

교재

1. 《쉽게 배우는 운영체제 3판》
2. 《Rosen의 이산수학》

《쉽게 배우는 운영체제 3판》은 운영체제의 기본 구조와 핵심 원리를 배우고자 하는 IT학과 학생을 대상으로 한다. (Kyobo Bookstore) 《Rosen의 이산수학》은 이산수학의 표준 교재 계열로 국내 판매 정보가 확인된다. (Yes24)

실습 산출물

os-discrete-lab/
  process_demo.py
  thread_demo.py
  file_permission_notes.md
  finite_state_machine.py
  graph_validation.py

통과 기준

• 프로세스와 스레드 차이를 설명한다.
• 파일 권한 오류를 해결할 수 있다.
• LangGraph 같은 상태 그래프를 수학적으로 “상태와 전이”로 설명할 수 있다.

5. 7~12개월: 기본 단계

목표

이 단계는 EdgeCanvas의 물리 세계 기반을 만드는 단계다.

12개월차가 끝나면 다음이 되어야 한다.

• STM32와 ESP32 계열 개발환경을 구축한다.
• 보드에 예제를 빌드·플래시한다.
• LVGL 화면을 띄운다.
• OpenCV로 USB 카메라 화면을 읽는다.
• LCD 화면 검증기를 만든다.
• Docker/pytest 기반으로 실험을 재현한다.

7개월차: 디지털논리 / 전자회로 기초

공부할 것

• 0/1 전압 레벨
• 논리게이트
• 플립플롭
• 레지스터
• 클럭
• setup/hold time
• pull-up / pull-down
• GPIO
• I2C
• SPI
• UART
• PWM
• ADC
• 전원/그라운드

교재

1. 《Floyd의 디지털 논리회로》
2. 보조: 《마이크로전자회로》는 필요한 부분만

실습 산출물

electronics-notes/
  gpio.md
  uart.md
  spi_i2c.md
  clock_timing.md

통과 기준

• GPIO 입력/출력 차이를 설명한다.
• I2C, SPI, UART 차이를 설명한다.
• 왜 LCD와 Touch가 서로 다른 버스를 쓸 수 있는지 설명한다.

8개월차: 임베디드 시스템 개론

공부할 것

• MCU
• HAL
• BSP
• RTOS 기초
• 인터럽트
• 타이머
• DMA
• UART 로그
• Flash / RAM
• 부트로더
• linker script 개념

교재

1. 《임베디드 엔지니어 교과서》
2. 《임종수의 STM32 Cortex-M 완벽 활용서 Vol.1》 시작

《임베디드 엔지니어 교과서》는 하드웨어·소프트웨어 지식, 임베디드 프로그램 개요, 실시간 운영체제, 임베디드 소프트웨어 개발 프로세스 등을 다룬다고 소개된다. (Google Books) 《임종수의 STM32 Cortex-M 완벽 활용서 Vol.1》은 STM32 MCU 소개, CubeIDE/CubeMX/IAR/Keil 설치, GPIO 사용 등을 다루는 책으로 확인된다. (Kyobo Bookstore)

공식문서

• STM32H747I-DISCO 제품 페이지
• STM32H747I-DISCO User Manual
• STM32CubeH7 예제

STM32H747I-DISCO는 STM32H747XIH6 마이크로컨트롤러 기반의 데모·개발 플랫폼이다. (STMicroelectronics) ST의 User Manual은 보드가 STM32H747XIH6를 중심으로 설계되어 있고 주변 컴포넌트 연결 구조를 설명한다. (STMicroelectronics)

실습 산출물

stm32-lab/
  gpio_blink/
  uart_log/
  timer_interrupt/
  notes/
    board_profile_stm32h747i_disco.md

통과 기준

• LED blink를 직접 빌드·플래시한다.
• UART 로그를 출력한다.
• STM32 보드 프로필 문서를 작성한다.

9개월차: ESP32-S3 / M5Stack CoreS3

공부할 것

• ESP-IDF 설치
• menuconfig
• build / flash / monitor
• ESP32-S3 구조
• M5Stack CoreS3 LCD / Touch / Camera
• USB-C 플래시
• PSRAM / Flash

공식문서

• M5Stack CoreS3 공식문서
• ESP-IDF Programming Guide

M5Stack CoreS3는 ESP32-S3 기반 장치이며 16MB Flash, 8MB PSRAM, USB Type-C 다운로드/플래시를 지원한다고 설명된다. (M5Stack Docs) ESP-IDF는 Espressif의 ESP32/ESP32-S/ESP32-C/ESP32-H/ESP32-P 계열 SoC용 공식 개발 프레임워크이며, 공식 가이드는 환경 설정, menuconfig, build, flash 과정을 안내한다. (Espressif Systems)

실습 산출물

m5stack-cores3-lab/
  hello_world/
  lcd_test/
  camera_test/
  board_profile_m5stack_cores3.json

통과 기준

• ESP-IDF hello_world를 빌드·플래시한다.
• M5Stack CoreS3의 LCD 또는 기본 디스플레이 예제를 실행한다.
• STM32와 M5Stack의 차이를 보드 프로필로 정리한다.

10개월차: LVGL 기본

공부할 것

• LVGL object model
• screen
• label
• button
• image
• style
• event
• display driver
• input device
• tick
• memory buffer
• image converter

공식문서

• LVGL 공식 문서
• LVGL 포팅 문서
• STM32/LVGL 예제
• ESP-IDF/LVGL 예제

LVGL은 MCU, MPU, 다양한 디스플레이 타입을 대상으로 UI를 만들기 위한 무료 오픈소스 임베디드 그래픽 라이브러리로 설명된다. (LVGL)

실습 산출물

lvgl-lab/
  hello_label/
  button_event/
  image_widget/
  ui_schema/
    simple_dashboard.json
  generated/
    simple_dashboard.c

통과 기준

• 버튼 클릭 이벤트를 구현한다.
• JSON UI 스키마를 설계한다.
• JSON을 읽어 LVGL C 코드 일부를 자동 생성한다.

11개월차: 빌드 시스템 / CMake / 컴파일 / 링크

공부할 것

• Makefile
• CMake
• gcc
• cross compile
• object file
• static library
• include path
• linker script
• map file
• compile error
• link error
• binary flashing

공식문서

• CMake 튜토리얼
• Arm GNU Toolchain
• OpenOCD
• ST-LINK
• ESP-IDF build system

EdgeCanvas 문서에서도 CMake, Make, arm-none-eabi-gcc, ESP-IDF, ST-Link, OpenOCD, pyserial이 기술스택으로 들어 있다.

실습 산출물

build-lab/
  makefile_project/
  cmake_project/
  gcc_error_parser.py
  flash_stm32.sh
  flash_esp32.sh

통과 기준

• 컴파일 에러와 링크 에러를 구분한다.
• 빌드 로그에서 에러 파일명/라인/원인을 추출한다.
• Python에서 빌드 명령을 실행하고 결과 JSON을 생성한다.

12개월차: OpenCV 기반 Vision-in-the-Loop 기초

공부할 것

• 이미지 배열
• RGB/BGR
• 좌표계
• VideoCapture
• threshold
• contour
• template matching
• color histogram
• OCR은 보조
• PASS/FAIL 판정

교재

1. 《OpenCV 4로 배우는 컴퓨터 비전과 머신 러닝》

이 책은 OpenCV로 밝기·명암비 조절, 필터링, 에지 검출, 객체 검출, 영상 매칭, 필기체 숫자 인식까지 다루는 책으로 확인된다. (Kyobo Bookstore) 저자 페이지에서도 OpenCV를 이용해 컴퓨터비전과 머신러닝 알고리즘을 구현하는 방법을 설명한다고 소개한다. (Sunkyoo Hwang)

공식문서

• OpenCV 공식 문서
• OpenCV GitHub / docs

OpenCV는 오픈소스 컴퓨터비전 라이브러리이며 C++, Python 등의 API와 문서·테스트를 제공한다. (GitHub)

실습 산출물

vision-loop-lab/
  capture_camera.py
  detect_lcd_region.py
  compare_color.py
  compare_layout.py
  report.json

통과 기준

• USB 카메라에서 프레임을 받는다.
• LCD 영역을 잘라낸다.
• 기준 이미지와 실제 이미지를 비교한다.
• PASS/FAIL 리포트를 JSON으로 만든다.

6. 13~18개월: 심화 단계

목표

이제부터는 “보드 실습”을 넘어 AI Agent 시스템으로 들어간다.

18개월차가 끝나면 다음이 가능해야 한다.

• 머신러닝/딥러닝의 기본 원리를 설명한다.
• 문서 파싱과 정보 추출을 API로 수행한다.
• RAG와 structured output을 구현한다.
• LangGraph 상태머신을 만든다.
• 빌드 실패와 Vision 실패를 수정 루프로 연결한다.
• API 키, Docker, 네트워크, 보안을 고려한다.

13개월차: 선형대수 / 확률통계

공부할 것

선형대수:

• 벡터
• 행렬
• 행렬곱
• 역행렬
• 고유값
• SVD 맛보기
• 좌표 변환
• 최소제곱

확률통계:

• 확률변수
• 조건부확률
• 베이즈 정리
• 기댓값
• 분산
• 정규분포
• 신뢰구간
• precision / recall
• confusion matrix

교재

1. 《스트랭 선형대수학》
2. 《이공계용 확률과 통계》

《스트랭 선형대수학》은 Gilbert Strang 교수의 MIT 선형대수학 강의를 기반으로 구성된 6판 번역서로 확인된다. (Kyobo Bookstore) 《이공계용 확률과 통계》는 Sheldon M. Ross의 공학·과학 계열 확률통계 교재로 확인된다. (Kyobo Bookstore)

EdgeCanvas 연결

• Vision 판정 일치율
• 색상/위치 오차
• threshold 설정
• 평가 지표
• 센서 노이즈
• AegisEdge 객체탐지 평가

실습 산출물

math-for-vision/
  matrix_transform.ipynb
  confusion_matrix.py
  pass_fail_statistics.py

통과 기준

• 검증 결과 100개를 가지고 정확도, 정밀도, 재현율을 계산한다.
• 화면 위치 오차를 픽셀 단위로 계산한다.

14개월차: 머신러닝 / 딥러닝 기초

공부할 것

• supervised learning
• loss
• gradient descent
• overfitting
• train/validation/test
• CNN
• transformer 개념 맛보기
• embedding
• inference
• evaluation

교재

1. 《혼자 공부하는 머신러닝+딥러닝》
2. 《밑바닥부터 시작하는 딥러닝 1》

《혼자 공부하는 머신러닝+딥러닝》 개정판은 머신러닝과 딥러닝 핵심을 직관적 예제로 설명하고, 트랜스포머와 LLM 실습, PyTorch 예제를 보강했다고 소개된다. (혼자 공부하는 책)

실습 산출물

ml-lab/
  image_classifier.ipynb
  simple_cnn.py
  evaluation_report.md

통과 기준

• train/validation/test를 구분한다.
• overfitting을 설명한다.
• 작은 이미지 분류 모델을 학습해 본다.

15개월차: 자연어처리 / Transformer / RAG

공부할 것

• token
• embedding
• attention
• transformer
• chunking
• vector search
• RAG
• structured output
• hallucination
• prompt injection 기초

교재

1. 《밑바닥부터 시작하는 딥러닝 2》
2. 《트랜스포머를 활용한 자연어 처리》

EdgeCanvas 연결

EdgeCanvas의 데이터시트 해석은 결국 문서 이해 문제다. 구현제안서에서도 Document Parse와 Information Extract로 레지스터 맵, 핀맵, 클럭 트리, 타이밍 제약을 JSON 스키마로 추출한다고 되어 있다.

실습 산출물

rag-lab/
  chunk_datasheet.py
  extract_schema.py
  schema_validator.py
  retrieval_demo.py

통과 기준

• PDF/Markdown 문서를 chunk로 나눈다.
• 검색 결과를 근거로 JSON을 만든다.
• 추출된 JSON을 Pydantic으로 검증한다.

16개월차: Upstage Document AI / Solar Pro 3 API

공부할 것

• Document Parse
• Information Extract
• JSON schema extraction
• API authentication
• rate limit
• retry
• error handling
• prompt template
• structured output

공식문서

• Upstage Document Parse
• Upstage Information Extract
• Solar Pro 3 관련 문서

Upstage Document Parse는 PDF, 스캔 이미지, 복잡한 차트 등을 LLM이 처리하기 쉬운 HTML/Markdown 같은 구조화 형식으로 변환하는 제품으로 설명된다. (upstage.ai) Information Extract는 다양한 문서에서 구조화 데이터를 추출하는 기능으로 설명된다. (upstage.ai) Solar Pro 3는 Upstage Console에서 API로 사용할 수 있다고 Upstage 블로그에서 설명한다. (upstage.ai)

실습 산출물

document-ai-lab/
  parse_datasheet.py
  extract_mcu_schema.py
  schemas/
    mcu_schema.json
    lvgl_constraints.json
  outputs/
    stm32_sample_extraction.json

통과 기준

• 데이터시트 1개에서 최소 10개 필드를 추출한다.
• 추출 실패와 누락 필드를 기록한다.
• 사람이 검토한 정답 JSON과 비교한다.

17개월차: LangGraph Agent / 상태머신

공부할 것

• StateGraph
• node
• edge
• conditional edge
• retry loop
• checkpoint
• tool calling
• human-in-the-loop
• evaluator
• self-healing

교재

1. 《LangGraph로 만드는 AI 에이전트 서비스》
2. 《혼자서도 척척 해내는 AI 에이전트 만들기 with 랭체인 & 랭그래프》

공식문서

• LangGraph 공식문서
• LangChain tools 문서
• Pydantic 문서

LangGraph는 장기 실행되는 stateful workflow 또는 agent를 위한 저수준 인프라를 제공한다고 공식 문서에 설명되어 있다. (LangChain Docs) LangGraph는 long-running, stateful agent를 구축·관리·배포하기 위한 low-level orchestration framework로도 설명된다. (GitHub)

실습 산출물

edgecanvas-agent/
  graph.py
  nodes/
    parse_datasheet.py
    extract_schema.py
    generate_lvgl.py
    build_firmware.py
    flash_device.py
    verify_screen.py
    fix_code.py
  state.py
  tests/

통과 기준

다음 루프가 mock으로라도 돌아가야 한다.

parse_datasheet
→ extract_schema
→ generate_lvgl
→ build_firmware
→ verify_screen
→ if failed: fix_code
→ if passed: report

18개월차: 네트워크 / HTTP / Docker / 보안 기초

공부할 것

네트워크:

• TCP/IP
• DNS
• HTTP
• REST API
• TLS
• WebSocket
• RTSP 맛보기
• timeout
• retry
• rate limit

Docker:

• image
• container
• volume
• network
• Dockerfile
• docker compose

보안:

• API key
• 환경변수
• secret leakage
• path traversal
• command injection
• prompt injection
• dependency vulnerability

교재

1. 《컴퓨터 네트워킹: 하향식 접근》
2. 《HTTP 완벽 가이드》
3. 《도커 교과서》
4. KISA 시큐어코딩 가이드

《컴퓨터 네트워킹: 하향식 접근》은 컴퓨터 네트워킹의 기초와 전반을 학습할 수 있도록 구성된 교재로 확인된다. (Kyobo Bookstore) Docker 공식 문서는 컨테이너를 이미지의 실행 가능한 인스턴스로 설명하며, Docker API/CLI로 생성·시작·중지·삭제할 수 있다고 설명한다. (Docker Documentation)

실습 산출물

deployment-security-lab/
  Dockerfile
  docker-compose.yml
  .env.example
  secure_subprocess.py
  api_client_with_retry.py
  security_checklist.md

통과 기준

• API key를 코드에 하드코딩하지 않는다.
• Docker로 동일한 CLI를 재현 실행한다.
• 외부 명령 실행 시 allowlist를 적용한다.

7. 19~24개월: 실전 단계

목표

이제 최종 목표는 EdgeCanvas MVP + AegisEdge 확장 프로토타입 + 기술문서 + 포트폴리오다.

구현제안서의 구현범위도 세부업무 #1 데이터시트 구조화, #2 하드웨어 제약 기반 HMI 설계 및 다중 타깃 코드 합성, #3 Vision-in-the-Loop 기반 피지컬 구동 검증 및 Self-Healing 폐쇄 루프로 나뉘어 있다.

19개월차: EdgeCanvas MVP 1 — 데이터시트 → JSON

구현 목표

MCU PDF / Markdown
→ Document Parse
→ Information Extract
→ MCU hardware schema
→ validation report

산출물

edgecanvas/
  schemas/
    mcu_schema.py
    board_profile.py
  parsers/
    upstage_document_parse.py
    information_extract.py
  examples/
    stm32h747i_disco.json
    m5stack_cores3.json
  reports/
    extraction_report.md

성공 기준

• STM32 또는 M5Stack 관련 문서에서 최소 필드를 추출한다.
• 추출 결과를 사람이 검토할 수 있는 리포트로 만든다.
• Pydantic validation을 통과한다.

20개월차: EdgeCanvas MVP 2 — JSON → LVGL C 코드

구현 목표

UI requirement
→ UI schema
→ LVGL widget tree
→ generated C code

산출물

edgecanvas/
  ui_schema/
    widgets.py
    layout.py
  generators/
    lvgl_generator.py
  templates/
    lvgl_screen.c.j2
    lvgl_events.c.j2
  generated/
    dashboard_screen.c

성공 기준

• label/button/image 최소 3개 위젯을 생성한다.
• 이벤트 핸들러 코드를 생성한다.
• 생성 코드는 gcc 또는 타깃 빌드에서 문법 오류 없이 통과한다.

21개월차: EdgeCanvas MVP 3 — 빌드 / 플래시 자동화

구현 목표

generated C project
→ build
→ binary
→ flash
→ serial log

산출물

edgecanvas/
  builders/
    cmake_builder.py
    espidf_builder.py
  flashers/
    stlink.py
    esptool.py
  logs/
    build_log.json
    flash_log.json

성공 기준

• 빌드 명령을 Python에서 실행한다.
• 실패 시 에러를 구조화한다.
• 성공 시 binary 경로를 기록한다.
• 플래시 명령을 실행하거나 dry-run으로 검증한다.

22개월차: EdgeCanvas MVP 4 — Vision-in-the-Loop

구현 목표

camera capture
→ LCD region detection
→ expected UI comparison
→ PASS/FAIL
→ report

산출물

edgecanvas/
  vision/
    capture.py
    lcd_detector.py
    layout_compare.py
    color_compare.py
    report.py
  reports/
    vision_report.html
    vision_report.json

성공 기준

• 화면 검은색/흰색 죽음 상태를 감지한다.
• 버튼 위치/색상/텍스트 존재 여부를 검증한다.
• PASS/FAIL 결과를 JSON과 HTML로 생성한다.

23개월차: EdgeCanvas MVP 5 — LangGraph Self-Healing 통합

구현 목표

extract schema
→ generate code
→ build
→ flash
→ verify
→ failed?
   → fix prompt
   → regenerate
   → retry

산출물

edgecanvas/
  graph/
    state.py
    workflow.py
    conditions.py
  evaluators/
    build_evaluator.py
    vision_evaluator.py
  fixers/
    code_fixer.py
    ui_fixer.py

성공 기준

• 빌드 실패 시 코드 수정 루프로 돌아간다.
• Vision 실패 시 UI 수정 루프로 돌아간다.
• 최대 retry 횟수를 제한한다.
• 모든 step이 로그로 남는다.

이 부분은 EdgeCanvas 문서의 “LangGraph 상태머신이 전 계층 전이를 제어하며, 불일치 시 자가 수정 루프를 자율 실행”한다는 구조와 직접 맞닿아 있다.

24개월차: 최종 통합 / AegisEdge 프로토타입 / 포트폴리오

EdgeCanvas 최종 산출물

edgecanvas/
  README.md
  docs/
    architecture.md
    board_profile.md
    security.md
    benchmark.md
  examples/
    stm32_demo/
    m5stack_demo/
  docker/
    Dockerfile
  tests/
  reports/

AegisEdge 선택 프로토타입

AegisEdge가 영상분석 방향이면 다음을 만든다.

aegisedge-prototype/
  capture/
    rtsp_or_usb.py
  inference/
    yolo_or_onnx.py
  events/
    event_schema.py
  api/
    server.py
  dashboard/
    simple_viewer.py

AegisEdge가 로봇 방향이면 ROS2는 이때부터 들어간다. 이전 정리 문서에서도 ROS2는 EdgeCanvas 본체 1순위가 아니라, AegisEdge가 로봇과 연결되거나 EdgeCanvas가 서비스 로봇 HMI와 연동될 때 학습하는 후순위 자료로 분리했다.

최종 성공 기준

• GitHub README만 보고 설치 가능하다.
• Docker로 실행 가능하다.
• 테스트가 자동 실행된다.
• 보드 프로필이 2개 이상 있다.
• 샘플 데이터시트 또는 샘플 JSON이 포함된다.
• Vision-in-the-Loop 리포트가 자동 생성된다.
• 실패 로그와 자가수정 라운드 수가 기록된다.

8. 24개월 월별 전체표

9. 교재 구매 순서

1차 구매: 1~6개월용

이 10권이 기초 체력이다.

1. 《리눅스 커맨드라인 완벽 입문서》
2. 《혼자 공부하는 파이썬》
3. 《윤성우의 열혈 C 프로그래밍》
4. 《C로 배우는 쉬운 자료구조 4판》
5. 《컴퓨터 구조 및 설계 ARM》
6. 《쉽게 배우는 운영체제 3판》
7. 《Rosen의 이산수학》
8. 《Floyd의 디지털 논리회로》
9. 《스트랭 선형대수학》
10. 《이공계용 확률과 통계》

이전 정리 문서에서도 현실적인 첫 교재로 리눅스, Python, C, 자료구조, 컴퓨터구조, 운영체제, 이산수학, 선형대수, 임베디드, OpenCV가 제시되어 있다.

2차 구매: 7~12개월용

1. 《임베디드 엔지니어 교과서》
2. 《임종수의 STM32 Cortex-M 완벽 활용서 Vol.1》
3. 《OpenCV 4로 배우는 컴퓨터 비전과 머신 러닝》
4. 필요 시 《임베디드 프로그래밍 C 코드 최적화》

3차 구매: 13~18개월용

1. 《혼자 공부하는 머신러닝+딥러닝》
2. 《밑바닥부터 시작하는 딥러닝 1》
3. 《밑바닥부터 시작하는 딥러닝 2》
4. 《트랜스포머를 활용한 자연어 처리》
5. 《LangGraph로 만드는 AI 에이전트 서비스》
6. 《컴퓨터 네트워킹: 하향식 접근》
7. 《HTTP 완벽 가이드》
8. 《도커 교과서》

4차 구매: 19~24개월 선택

AegisEdge가 영상분석이면:

1. 《IT CookBook, 컴퓨터 비전과 딥러닝》
2. YOLO/ONNX/DeepStream 공식문서 중심

AegisEdge가 로봇이면:

1. 《ROS2 혼자공부하는 로봇SW 직접 만들고 코딩하자》
2. 《ROS 2로 시작하는 로봇 프로그래밍》
3. ROS2/Nav2/Gazebo 공식문서

AegisEdge가 관제/보안/정책엔진이면:

1. 《소프트웨어 공학의 모든 것》
2. 《실용주의 프로그래머》
3. KISA 시큐어코딩 가이드
4. MCP/A2A 공식문서

10. 공식문서 읽는 순서

교재보다 공식문서가 중요한 영역이 있다. 이전 정리 문서에서도 LVGL 9.x, STM32H747I-DISCO, ESP-IDF/M5Stack CoreS3, Upstage API, LangGraph, OpenCV/DeepStream/YOLO는 버전 변화가 있어 공식문서 우선이라고 정리했다.

1순위 공식문서

1. STM32H747I-DISCO User Manual
2. ESP-IDF Programming Guide
3. M5Stack CoreS3 공식문서
4. LVGL 공식문서
5. OpenCV 공식문서
6. Upstage Document Parse / Information Extract / Solar Pro 3
7. LangGraph 공식문서
8. Docker 공식문서
9. CMake 공식문서
10. DeepStream 공식문서, AegisEdge 영상분석 시

11. 주간 공부 루틴

매주 이렇게 반복한다.

월요일

교재 1장 읽기. 핵심 용어 10개 정리.

화요일

공식문서 읽기. 교재와 공식문서 차이 정리.

수요일

코딩 실습. 작게라도 동작하는 예제를 만든다.

목요일

실패 로그 분석. 에러 메시지를 원인별로 분류한다.

금요일

README 작성. “내가 뭘 배웠는지”가 아니라 “다른 사람이 어떻게 재현하는지”를 쓴다.

토요일

미니 프로젝트 구현.

일요일

복습, 정리, 다음 주 계획.

12. 매달 평가 기준

매달 아래 5개를 체크한다.

점수는 5점 만점으로 기록한다.

2년 동안 목표는 모든 핵심 영역을 4점 이상으로 만드는 것이다.

13. EdgeCanvas 관점 핵심 역량 우선순위

14. AegisEdge 관점 핵심 역량 우선순위

15. 하지 말아야 할 순서

아래 순서로 가면 위험하다.

LLM Agent → ROS2 → Isaac Sim → 강화학습 → 임베디드

이 순서는 멋있어 보이지만 EdgeCanvas에는 비효율적이다. 왜냐하면 EdgeCanvas의 본질은 실물 MCU, LVGL, 빌드/플래시, 카메라 검증이기 때문이다.

올바른 순서는 다음이다.

리눅스
→ Python
→ C
→ 자료구조
→ 컴퓨터구조
→ 운영체제
→ 디지털논리
→ 임베디드
→ LVGL
→ OpenCV
→ 문서 AI
→ LangGraph
→ Docker/보안
→ EdgeCanvas MVP
→ AegisEdge 확장

이전 정리 문서에서도 “기초 학문은 AI부터가 아니라 리눅스 → Python → C → 자료구조 → 컴퓨터구조 → 운영체제 → 이산수학 → 임베디드 → 선형대수/확률통계 → OpenCV → 딥러닝 → LangGraph Agent → 네트워크/보안/소프트웨어공학” 순서가 맞다고 정리했다.

16. 최종 요약

2년 커리큘럼의 핵심은 이렇다.

기초, 1~6개월

리눅스, Git, Python, C, 자료구조, 컴퓨터구조, 운영체제, 이산수학을 한다. 목표는 시스템을 이해하는 개발자 기본기다.

기본, 7~12개월

디지털논리, 임베디드, STM32, M5Stack, ESP-IDF, LVGL, CMake, OpenCV를 한다. 목표는 실물 보드에 HMI를 띄우고 카메라로 검증하는 능력이다.

심화, 13~18개월

선형대수, 확률통계, 머신러닝, 딥러닝, NLP, RAG, Upstage 문서 AI, LangGraph, 네트워크, Docker, 보안을 한다. 목표는 문서 이해와 자가수정 Agent를 설계하는 능력이다.

실전, 19~24개월

EdgeCanvas MVP를 만든다. 목표는 데이터시트 → JSON → LVGL C 코드 → 빌드 → 플래시 → 카메라 검증 → 자가수정 리포트까지 연결하는 것이다.

가장 중요한 결론은 하나다.

EdgeCanvas를 제대로 하려면 AI보다 먼저 C, 컴퓨터구조, 임베디드, LVGL, OpenCV, LangGraph를 순서대로 쌓아야 한다. AegisEdge까지 생각하면 그 위에 네트워크, Docker, 딥러닝 객체탐지, DeepStream, 보안을 얹으면 된다.

1) LLMOps/AI 운영(서비스화·운영자동화) 쪽 유사 사업 2026년도 공공AX 프로젝트 사업 신규과제 모집 공고 (진행중)

기간: 2026-02-11 ~ 2026-03-16 링크: https://www.nipa.kr/home/2-2/16471 성격: 공공영역 AI 도입/운영, MLOps·LLMOps 구조 제안에 잘 맞음 2026년도 AI 응용제품 신속 상용화 지원사업 (Type2: AI 민생 프로젝트) (예정)

기간: 2026-03-02 ~ 2026-03-16 링크: https://www.nipa.kr/home/2-2/16475 성격: 모델을 제품/서비스로 빠르게 상용화하는 트랙 2026년 AI바우처 지원사업 공급기업 POOL 모집 공고 (진행중)

기간: 2026-02-10 ~ 2026-02-24 링크: https://www.nipa.kr/home/2-2/16469 성격: AI 솔루션 공급기업 등록(LLM 서비스 운영기업에게 중요) 2026년도 중소기업 클라우드 서비스 보급·확산 사업 공급기업 모집 (진행중)

기간: 2026-02-13 ~ 2026-03-20 링크: https://www.nipa.kr/home/2-2/16474 성격: LLM 서비스 운영 인프라(클라우드, 운영체계) 연계에 유리 2026년도 AI·디지털 비즈니스 파트너십 특화 프로그램 참여기업 모집 (진행중)

기간: 2026-02-05 ~ 2026-03-05 링크: https://www.nipa.kr/home/2-2/16463 2) CVOps/제조 비전·영상분석 쪽 유사 사업 [경기] 스마트공장 구축 및 컨설팅·제조AI 지원사업 (진행중)

기간: 2026-02-10 ~ 2026-03-20 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000118448 [강원] 강원형 스마트공장(기초단계) 구축지원사업 (예정)

기간: 2026-03-03 ~ 2026-03-23 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000118437 [울산] AI기반 PoC 실증 지원사업(지역특화 제조데이터 활성화) (진행중)

기간: 2025-11-19 ~ 2026-02-28 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000116436 중소제조 특화 Multi AI Agent 개발(R&D) (예정)

기간: 2026-03-01 ~ 2026-03-31 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000116030 제조AI특화 스마트공장(자율형공장 AI트랙) (예정)

기간: 2026-03-01 ~ 2026-04-30 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000115998 민군경 AI 기반 해양영상 융복합 분석기술개발 (마감, 유사도 높음)

기간: 2026-01-26 ~ 2026-02-19 링크: https://www.bizinfo.go.kr/sii/siia/selectSIIA200Detail.do?pblancId=PBLN_000000000117465

1.1 학습 목표

1.1.1 GPT-3 등장

• 하나의 모델로 다양한 업무를 하려는 흐름
• Pretrain → Transfer
• Few-shot / Zero-shot

1.1.2 Transformer의 중요성

• RNN/LSTM의 한계를 Attention으로 해결

1.1.3 NLP의 핵심 난제

• 순서가 의미를 바꿈
• 단어 하나 변화가 의미 및 라벨을 뒤집음 (ex: “안”)
• 토큰화와 OOV(사전에 없는 단어)가 실무 난이도를 크게 좌우

1.1.4 기초 수식

• 언어 모델 확률(체인 룰)
• 내적 = 유사도
• softmax가 확률이 되는 이유

1.2 GPT-3

1.2.1 GPT-3 방향성

• Task마다 모델을 새로 만들고 라벨을 많이 모아 학습하는 방식은 비용이 큼
• 큰 모델을 미리 학습(Pretrain)해두고, 적은 예시(Few-shot) 또는 예시 없이(Zero-shot) 다양한 Task를 수행하게 하려는 방향

1.2.2 GPT-3 핵심 동기

• Transformer가 번역에서 성공 → “Transformer 구조로 더 잘할 수 없을까?”
• Task 및 Domain이 바뀌면 성능이 떨어지는 문제
• 다양한 데이터로 미리 학습하면 새로운 Task 적응이 쉬워진다로 개념 발전

1.3 Transformer 핵심

• Attention
• Positional Encoding

1.3.1 Self-Attention

• 문장 안의 각 토큰이 문장 내 다른 토큰들을 참고해서 자기 표현을 업데이트

토큰 i의 새 표현 = (토큰 1을 보는 비율)*v1
               + (토큰 2를 보는 비율)*v2
               + ...
               + (토큰 n을 보는 비율)*vn

1.3.2 Positional Encoding

• Transformer는 구조적으로 순서 정보가 자동으로 들어가지 않음
• 토큰 위치 정보를 숫자 벡터로 추가해서 순서를 인지하게 만들어야 함

1.4 데이터 관점 비교

1.4.1 Tabular vs Vision vs NLP

1.5 토큰화

1.5.1 토큰화란

• 문장을 모델이 먹을 수 있는 단위로 쪼개고 각 조각을 숫자로 바꾸는 과정

1.5.2 토큰화 단위

• Character

  • 예: 나는 → [나, 는]
  • 장점: OOV 거의 없음
  • 단점: 길이 폭증, 의미 단위가 약함

• Space

  • 예: I love apples → [I, love, apples]
  • 장점: 단순함
  • 단점: “tokenization!” vs “tokenization” 같은 변형에 취약, 한국어는 공백이 의미 단위와 안 맞는 경우가 많음

• Punctuation

  • 구두점 기준 분리
  • 장점: 일부 개선
  • 단점: 근본 해결은 아님

• Subword

  • 예: unbelievable → [un, believe, able]
  • OOV를 크게 줄이면서 길이 폭증도 완화
  • 대표: GPT 계열(BPE), BERT 계열(WordPiece)

1.6 언어 모델

• 문장을 확률로 모델링

1.6.1 문장 확률

• 체인 룰(Chain Rule)로 분해
• 문장을 단어들의 나열로 보면 길이 (T)인 문장은 다음처럼 표현 가능

$$ (W_1, W_2, \ldots, W_T) $$

• 문장 전체 결합확률은 체인 룰로 다음처럼 분해

$$ P(W_1, W_2, \ldots, W_T) = \prod_{t=1}^{T} P(W_t \mid W_{<t}) $$

• 여기서 (W_{<t})는 “(t)번째 단어 이전까지의 모든 단어들”을 의미

  • $$P(W_1)$$ : 첫 단어가 나올 확률
  • $$P(W_2 \mid W_1)$$ : 첫 단어가 주어졌을 때 두 번째 단어 확률
  • $$P(W_3 \mid W_1, W_2)$$ : 앞의 두 단어가 주어졌을 때 세 번째 단어 확률
  • $$P(W_T \mid W_1, \ldots, W_{T-1})$$ : 이전 단어들이 주어졌을 때 마지막 단어 확률

• 언어 모델은 한 문장을 한 번에 통째로 외우는 게 아님

• 즉, “지금까지 단어들이 주어졌을 때 다음 단어 확률”을 반복적으로 예측하고 그 확률들을 곱해서 문장 전체 확률을 구성

1.7 평가 지표

• 왜 번역/생성은 “정답률(Accuracy)”로 끝나지 않나

• 번역/요약/생성 태스크는 정답이 한 가지로 고정되지 않음

• 같은 의미라도 표현이 여러 가지가 가능하므로, “정확히 일치”만 보는 정답률로는 평가가 어려움

• 따라서 BLEU/ROUGE 같은 자동 평가 지표가 등장

1.7.1 핵심 지표 정리

• BLEU

  • 핵심: n-gram precision(겹치는 조각 비율) + brevity penalty(짧은 번역 패널티)
  • 장점: 자동 평가 가능
  • 한계: 의미가 같아도 표현이 다르면 낮게 나올 수 있음

• ROUGE

  • 요약에서 많이 사용
  • 성격: recall에 가까움(참고 요약의 내용이 얼마나 포함됐나)
  • 대표: ROUGE-N, ROUGE-L

• METEOR

  • 정렬(alignment) 관점이 강하고, 어간(stemming), 동의어 등을 고려(세부는 설정/버전에 따라 차이)

• Human Evaluation

  • 여전히 중요
  • 기준 예시: Adequacy(의미), Fluency(자연스러움)
  • pairwise 비교(둘 중 더 좋은 것 선택)가 안정적

1.8 트랜스포머 이전: RNN/LSTM 인코더-디코더(Seq2Seq)

• “문맥(context)을 하나로 요약하고 싶다” → 인코더-디코더 구조가 자연스럽게 등장

1.8.1 RNN 구조(시간축으로 펼침)

x1 -> [RNN] -> h1
            -> (다음으로 전달)
x2 -> [RNN] -> h2
x3 -> [RNN] -> h3
...

• (x_t): t번째 입력(토큰 임베딩)
• (h_t): t번째 은닉 상태(문맥 누적 정보)

1.8.2 인코더-디코더(번역) 개념

(Encoder)  한국어 토큰들 -> h1,h2,...,hT -> (context 요약)
(Decoder)  context + 이전 출력 -> 다음 단어 생성 -> ...

• 인코더: 입력 문장을 읽고 표현을 만듦
• 디코더: 인코더 요약(context) + 이전 출력 토큰을 바탕으로 다음 토큰 생성

1.8.3 한계가 생기는 이유

• 정보 병목(Bottleneck): 긴 문장을 하나의 context 벡터로 압축 → 앞부분 정보 손실
• 순차 처리의 한계: 병렬화가 어려움
• 장기 의존성 문제: 멀리 떨어진 정보 연결이 어렵고 학습이 불안정(대표: vanishing gradient)

1.9 Attention

• 어느 단어(토큰)에 더 집중할지 학습하여 중요한 정보에 더 큰 가중치를 주는 메커니즘

• 강의 요지

  • “I do not like …”에서 핵심은 not
  • 번역은 단어 정렬(alignment)이 중요 (한국어 앞 단어가 영어 뒤로 갈 수도 있음)

1.9.1 디코더-인코더 Attention 직관(Seq2Seq Attention)

• 디코더가 출력 토큰 하나(시점 (j))를 만들 때,
• 인코더의 모든 상태 ((h_1, \ldots, h_T)) 중 어디를 얼마나 참고할지(가중치)를 계산한다.

(1) 유사도 점수(score) 계산

$$ \text{score}_{j,i} = \mathrm{similarity}(\mathbf{s}_j, \mathbf{h}_i) $$

(2) softmax로 가중치(attention weight) 만들기

$$ \alpha_{j,i} = \frac{\exp(\text{score}{j,i})} {\sum{k=1}^{T}\exp(\text{score}_{j,k})} $$

(3) 가중합으로 컨텍스트 벡터(context vector) 만들기

$$ \mathbf{c}j = \sum{i=1}^{T} \alpha_{j,i},\mathbf{h}_i $$

기호 의미

• $$\mathbf{s}_j$$ : 디코더의 (j)번째 상태(hidden state)

• $$\mathbf{h}_i$$ : 인코더의 (i)번째 상태(hidden state)

• $$\alpha_{j,i}$$ : (j)번째 출력 생성 시 (i)번째 입력을 얼마나 참고할지 나타내는 가중치

  • $$\sum_{i=1}^{T}\alpha_{j,i} = 1$$

• $$\mathbf{c}_j$$ : 디코더 (j)시점의 컨텍스트 벡터(입력 정보를 정렬+요약해서 제공)

1.9.2 전사본 표현 교정(중요)

• 핵심 흐름은 동일: 유사도 점수 → softmax → 가중합
• 다만 실제 구현은 여러 변형이 존재한다.

(1) 전통 Seq2Seq Attention의 대표 변형

• Dot-product(내적 기반)

$$ \mathrm{similarity}(\mathbf{s}_j, \mathbf{h}_i) = \mathbf{s}_j^{\top}\mathbf{h}_i $$

• Additive(Bahdanau, MLP 기반)

$$ \mathrm{similarity}(\mathbf{s}_j, \mathbf{h}_i) = \mathbf{v}^{\top}\tanh(W_s\mathbf{s}_j + W_h\mathbf{h}_i) $$

(2) 트랜스포머 Attention과의 연결

• 트랜스포머는 같은 아이디어를 (Q, K, V)로 재구성해 효율적으로 만든 형태다.

$$ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V $$

1.10 선형대수 기초

• 목표

수식을 봤을 때 “아 유사도구나 / 아 확률로 바꾸는구나”를 즉시 캐치하기

1.10.1 벡터/행렬/전치(Transpose)

• 벡터(열벡터)

$$ \mathbf{h} \in \mathbb{R}^{d \times 1} $$

• 전치(Transpose)

$$ \mathbf{h}^{\top} \in \mathbb{R}^{1 \times d} $$

• 내적(Dot product): 결과는 스칼라

$$ \mathbf{h}^{\top}\mathbf{g} \in \mathbb{R} $$

1.10.2 내적이 왜 “유사도” 느낌인가?

(1) 코사인 유사도에 내적이 포함됨

$$ \cos(\theta) = \frac{\mathbf{a}^{\top}\mathbf{b}}{\lVert \mathbf{a}\rVert,\lVert \mathbf{b}\rVert} $$

• 방향이 비슷할수록 값이 커짐
• 정규화하면 내적이 곧 “방향 유사도”처럼 동작

(2) 거리(distance) 전개에도 내적이 등장

$$ \lVert \mathbf{x}-\mathbf{y}\rVert^{2} = \mathbf{x}^{\top}\mathbf{x} - 2\mathbf{x}^{\top}\mathbf{y} + \mathbf{y}^{\top}\mathbf{y} $$

• $$\mathbf{x}^{\top}\mathbf{y}$$ 가 커질수록(더 비슷할수록) 거리는 작아지는 구조
• 그래서 내적은 “유사도”로 자주 쓰인다

1.10.3 softmax가 왜 “확률”이 되나?

• softmax 정의

$$ \mathrm{softmax}(z_i) = \frac{e^{z_i}}{\sum_{k} e^{z_k}} $$

• 항상 0보다 큼
• 전체 합이 1
• 미분이 깔끔해 학습에 유리

✅ 실무 팁(수치 안정성)

$$ \mathrm{softmax}(\mathbf{z})i = \frac{e^{z_i - \max(\mathbf{z})}}{\sum{k} e^{z_k - \max(\mathbf{z})}} $$

• overflow 방지를 위해 보통 (\max(\mathbf{z}))를 빼고 계산
• 정규화 구조 때문에 결과 확률은 동일하게 유지된다

1.11 트랜스포머로 돌아오기: 왜 GPT/BERT가 여기서 나왔나?

• 트랜스포머는 RNN의 순차 처리를 버리고, Attention으로 문장 내 관계를 한 번에 계산할 수 있게 만든 구조

1.11.1 트랜스포머 Attention 블록(자체완결)

입력 X (토큰 임베딩 + 포지션)  [n x d]

Q = XWq
K = XWk
V = XWv

A = softmax( QK^T / sqrt(dk) )   [n x n]  // 토큰-토큰 관계표
출력 = A V                        [n x d]

• (A): 토큰-토큰 관계(어느 토큰이 어느 토큰을 얼마나 참고하는지)

1.11.2 Multi-Head가 왜 필요?

• 한 번의 관계표만으로는 관계의 종류를 다양하게 담기 어려움
• 여러 헤드가 서로 다른 관점(문법/의미/지시어/장거리 의존 등)으로 관계를 학습

1.12 GPT vs BERT: 같은 트랜스포머지만 목표가 다르다

1.12.1 전사본 표현 교정(중요)

• 트랜스포머도 임베딩 레이어(토큰 ID → 벡터)는 반드시 존재
• 다만 word2vec처럼 임베딩을 따로 만들고 고정하기보다,
• 모델 학습 과정에서 임베딩까지 end-to-end로 같이 최적화하는 경우가 일반적 → “임베딩을 따로 튜닝하는 비중이 줄었다”로 이해하면 자연스럽다

아래는 네가 준 내용을 강의 흐름 그대로 유지하면서, Velog에서 수식이 절대 안 깨지게 $$ ... $$로 통일하고, ASCII/표/shape 추적/핵심 교정까지 “교재” 톤으로 완성한 최종본이야. (원문에 있던 [ ] 수식 표기, 괄호/슬래시/루트 표기 흔들림, 인덱스 표기 혼동을 전부 정리했어.)

2. Transformer

1) Transformer

1.1 트랜스포머는 “인코더-디코더” 구조

• 입력 문장(소스)을 Encoder가 이해(표현 벡터로 변환)
• 출력 문장(타겟)을 Decoder가 생성(한 토큰씩)

슬라이드의 큰 흐름은 다음처럼 잡으면 된다.

Input (token + position)
 -> Encoder blocks (self-attention + FFN)
 -> Decoder blocks (masked self-attention + cross-attention + FFN)
 -> Linear + Softmax
 -> Output tokens

1.2 트랜스포머가 RNN보다 유리했던 이유

• 병렬 처리 가능: 토큰을 순차적으로 처리하지 않고, 한 번에 행렬 연산으로 처리
• 번역 태스크에서 성능(BLEU)과 효율이 강점으로 제시됨
• 이후 BERT/GPT가 트랜스포머 블록을 채택하면서 “사전학습 → 적응”의 표준이 됨

2) Positional Encoding

2.1 왜 필요한가?

• RNN은 입력이 x1 → x2 → x3 ... 순서대로 들어오므로 순서 정보가 구조에 내장
• 트랜스포머는 병렬 처리로 토큰을 동시에 다루므로, 그냥 두면 토큰의 위치를 모름
• 그래서 토큰 임베딩에 위치 정보를 더해 순서를 주입한다

입력 단계(개념)

token ids -> Embedding(d_model)
          -> + PositionalEncoding(d_model)
          -> Encoder/Decoder blocks

2.2 “그럼 위치를 숫자로 주면 되지 않나?”가 왜 위험한가

(A) 그냥 0,1,2,3… 더하기

• 값 스케일이 커지며 학습 안정성(초기 분포, 스케일)이 흔들릴 수 있음

(B) 0~1 정규화 (예: 0, 0.33, 0.66, 1)

• 문장 길이가 바뀌면 같은 “2번째 토큰”도 값이 바뀜 → 같은 위치가 일관된 의미를 갖기 어려움

(C) 원-핫/이진 벡터

• 길이에 무관하게 같은 위치에 같은 벡터를 할당 가능
• 하지만 위치 간 상대 거리/기하학적 관계를 표현하기가 까다로움(왜곡 가능)

2.3 Sinusoidal Positional Encoding (원 논문 정석)

• 짝수 차원에는 sin, 홀수 차원에는 cos를 번갈아 사용

$$ PE(pos, 2i) = \sin\left(\frac{pos}{10000^{\frac{2i}{d_{model}}}}\right) $$

$$ PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{\frac{2i}{d_{model}}}}\right) $$

직관(강의 흐름 정리)

• sin/cos 범위는 대략 ([-1, 1]) → 스케일 폭주 방지
• 차원마다 주파수가 달라서 짧은/긴 거리 관계를 다양한 해상도로 표현
• “위치 변화가 벡터를 회전시키는 것처럼” 이해해도 직관적으로 도움이 됨

2.4 (실전) Positional Encoding 구현 예시 (이해용)

import numpy as np

def positional_encoding(max_len: int, d_model: int) -> np.ndarray:
    pos = np.arange(max_len)[:, None]              # (max_len, 1)
    i = np.arange(d_model)[None, :]                # (1, d_model)

    angle_rates = 1 / (10000 ** (2 * (i // 2) / d_model))
    angles = pos * angle_rates                     # (max_len, d_model)

    pe = np.zeros_like(angles)
    pe[:, 0::2] = np.sin(angles[:, 0::2])          # even
    pe[:, 1::2] = np.cos(angles[:, 1::2])          # odd
    return pe                                      # (max_len, d_model)

3) Self-Attention / Scaled Dot-Product Attention

3.1 Q, K, V를 한 문장으로

• Query(Q): “지금 내가 무엇을 찾고 싶은가?”
• Key(K): “각 토큰이 어떤 특징을 갖고 있어 매칭 기준이 되는가?”
• Value(V): “매칭되면 실제로 가져올 정보(내용)는 무엇인가?”

요약하면, 관계의 기준(Q/K)과 실제 내용(V)을 분리하면 표현력이 좋아진다는 흐름이다.

3.2 수식(정석)

$$ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V $$

“Scaled(/sqrt(d_k))”의 의미 (중요)

• 내적 (QK^\top)는 차원 (d_k)가 커질수록 값의 분산이 커지기 쉬움
• 그대로 softmax에 넣으면 값이 과도하게 커져 softmax가 포화(거의 0/1) → 학습 불안정
• 그래서 (\sqrt{d_k})로 나눠 스케일을 안정화한다

3.3 차원(shape) 추적 (구현 실수 방지 핵심)

시퀀스 길이 (L), 모델 차원 (d_{model}), 헤드 차원 (d_k, d_v)

강의의 “(3×4)·(4×2)=(3×2)” 감각은 맞지만, 실제로는 X와 W의 shape를 일관되게 유지하는 게 핵심이다.

4) Masked Self-Attention (왜 디코더에서만 마스크?)

4.1 이유: 생성(Autoregressive)은 “미래 토큰”을 보면 안 됨

• 디코더는 다음 단어를 예측해야 함
• 예: I love you에서 love를 예측할 때, 미래 토큰 you를 보면 치팅
• 그래서 디코더 self-attention에는 look-ahead mask(상삼각 마스크)를 적용한다

마스크 직관

허용: 과거/현재
금지: 미래

t=2일 때 볼 수 있는 범위: [1..2]

4.2 구현 관점(핵심)

• 마스크로 가려지는 위치의 score에 매우 작은 값을 더함(실제로는 (-\infty)에 가까운 값)
• softmax를 거치면 해당 확률이 거의 0이 되어 영향이 사라짐

5) Multi-Head Attention (왜 헤드를 여러 개 쓰나?)

5.1 직관(강의 흐름)

• 어떤 헤드는 주어-동사 관계를 강하게 보고
• 어떤 헤드는 지시어/대명사 관계를 보고
• 어떤 헤드는 구문 패턴을 본다 → 한 가지 attention만으로 모든 관계를 잡기 어렵기 때문에 여러 관점(헤드)으로 본다

5.2 수식(정석)

$$ \mathrm{head}_i = \mathrm{Attention}(QW_i^Q,; KW_i^K,; VW_i^V) $$

$$ \mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head}_1, \ldots, \mathrm{head}_h)W^O $$

5.3 차원 설계 (Residual을 위한 “차원 맞추기”)

• residual add를 하려면 입력/출력 차원이 같아야 함
• 보통 (d_{model})을 헤드 수 (h)로 나눔

$$ d_k = d_v = \frac{d_{model}}{h} $$

• 각 헤드 출력 concat → 다시 ((L, d_{model}))로 돌아와 residual add 가능

6) Skip Connection + Layer Normalization (Add & Norm)

슬라이드에서도 “성능 향상: Skip / LayerNorm”을 따로 강조한다.

6.1 Residual(Skip) Connection

• 목적: 깊은 네트워크에서 그라디언트 흐름 개선 + 학습 안정화

$$ y = x + \mathrm{SubLayer}(x) $$

6.2 LayerNorm (BatchNorm과 차이)

• BatchNorm: 배치 통계에 의존 → 배치 작으면 불안정
• LayerNorm: 토큰(샘플) 내부 feature 차원 기준 정규화 → 배치 크기에 덜 민감

7) Encoder/Decoder 블록 전체 흐름 한 장 요약

7.1 Encoder (한 층)

X
 -> Multi-Head Self-Attention
 -> Add & Norm (Residual + LayerNorm)
 -> Feed Forward
 -> Add & Norm

7.2 Decoder (한 층)

Y (shifted right)
 -> Masked Multi-Head Self-Attention
 -> Add & Norm
 -> Encoder-Decoder Attention (Q: decoder, K/V: encoder)
 -> Add & Norm
 -> Feed Forward
 -> Add & Norm

8) (다음 챕터 대비) GPT vs BERT에서 어디가 달라지나?

• BERT: Encoder-only (양방향 문맥 이해)
• GPT: Decoder-only (masked self-attention 기반, 다음 토큰 생성)

따라서 이번 파트의 “Positional Encoding, (Masked) Multi-Head Attention, LayerNorm, Residual”은 그대로 GPT/BERT 이해의 기반이 된다.

아래는 네 원문을 강의 흐름 그대로 유지하면서, Velog에서 수식이 깨지지 않도록 전부 $$ ... $$로 통일하고, 표/ASCII/shape 추적/단계별 정리까지 “교재” 톤으로 완성한 최종본이야. 그대로 복붙하면 돼.

3. Transformer for Computer Vision (ViT, DETR)

0) 이 강의에서 얻어야 하는 것 (학습 목표)

1. 왜 비전에서 트랜스포머를 쓰려 했는지
2. ViT 핵심 아이디어: 이미지를 토큰 시퀀스로 바꿔 Transformer Encoder에 넣기
3. DETR 핵심 아이디어: Detection을 집합(set) 예측으로 바꾸고 NMS 제거
4. 두 모델 모두에서 Positional Encoding/Embedding이 왜 필수인지
5. 면접/실무에서 말할 수 있게: 장점·단점·언제 쓰는지

1) 도입: “NLP에서 되면 CV에서도 되지 않을까?” + CNN의 Inductive Bias

1.1 CNN이 강한 이유(Inductive Bias)

CNN은 이미지에 맞는 “가정”이 구조적으로 들어가 있어서, 비교적 적은 데이터에서도 잘 학습되는 경향이 있습니다.

• 가정 1: 지역성(Locality) 가까운 픽셀들이 의미를 만든다 → 작은 커널로도 잘 배움
• 가정 2: 가중치 공유(Weight Sharing) 같은 패턴(엣지 등)은 위치가 달라도 같은 필터로 잡힌다
• 가정 3: Translation Equivariance 물체가 이동하면 feature map도 같이 이동 (완전한 invariance는 pooling/구조 설계로 얻는 경우가 많음)

1.2 CNN의 취약점(강의 예시를 정확히 정리)

강의의 “눈/코/입 위치가 이상해도 얼굴로 인식” 요지는 다음처럼 정리하면 더 정확합니다.

• CNN은 국소 패턴은 매우 잘 잡지만,
• 전역 관계(눈-코-입의 상대 위치)를 “자동으로 강제”하진 않음
• 따라서 데이터/학습 조건에 따라 부분만 맞으면 전체를 맞다고 착각하는 문제가 생길 수 있음

2) ViT (Vision Transformer) — “이미지를 토큰으로 만든다”

핵심 문장: 이미지를 패치로 쪼개서, 각 패치를 토큰처럼 만들어 Transformer Encoder에 입력한다.

2.1 ViT 전체 흐름 (Step-by-step)

Step 1) Patchify: 이미지를 P×P 패치로 쪼갠다

• 입력 이미지:

$$ X \in \mathbb{R}^{H \times W \times C} $$

• 패치 크기: (P \times P)
• 패치 개수:

$$ N = \frac{H}{P}\cdot \frac{W}{P} $$

• 각 패치를 펼치기(flatten):

$$ x_{p,i} \in \mathbb{R}^{P^2\cdot C} $$

✅ shape 추적(예시)

• 이미지: (224\times224\times3)
• 패치: (16\times16)
• 패치 개수: (N=(224/16)^2=14^2=196)
• 패치 벡터 차원: (16^2\cdot3=768)

Step 2) Linear Projection: 패치를 D차원 토큰으로 바꾼다

• 학습 가능한 선형 변환(프로젝션):

$$ z_i = x_{p,i}W_E + b,\quad z_i \in \mathbb{R}^{D} $$

• 행렬 차원:

$$ W_E \in \mathbb{R}^{(P^2C)\times D} $$

Step 3) [CLS] 토큰 붙이기 + Positional Embedding 더하기

• 분류를 위해 맨 앞에 [CLS] 토큰 추가:

$$ Z_0 = [z_{\text{cls}};; z_1;; \dots;; z_N] $$

• 위치 정보를 잃기 때문에 Positional Embedding을 더함:

$$ Z = Z_0 + E_{\text{pos}} $$

여기서

$$ E_{\text{pos}} \in \mathbb{R}^{(N+1)\times D} $$

Step 4) Transformer Encoder 통과

• 표준 Encoder 블록(MHSA + FFN + Residual + LayerNorm)을 (L)번 반복

Step 5) MLP Head로 분류

• 마지막 층 출력에서 [CLS] 위치 벡터를 뽑아 분류:

$$ \hat{y} = \mathrm{MLP}(Z^{(L)}_{\text{cls}}) $$

2.2 (중요) ViT는 왜 큰 데이터가 필요했나?

강의의 “그냥 쓰면 훈련이 잘 안 된다”는 말을 원인-결과로 정확히 정리하면:

• CNN은 이미지에 맞는 inductive bias(지역성/공유/계층)가 있어서 상대적으로 적은 데이터에서도 안정적으로 학습되는 편
• 초기 ViT는 그 bias가 약해서 “무슨 패턴을 우선 배워야 하는지”를 데이터에서 더 많이 배워야 했음
• 그래서 논문에서 대규모 데이터로 pretrain 후 fine-tune을 강조(JFT-300M 등)

2.3 ViT 시각화 결과(강의 포인트 3가지)

1. Embedding filter가 low-level 패턴을 학습

• CNN 1층이 엣지/텍스처를 배우듯, ViT 초기 층에서도 유사 패턴이 나타남

2. Positional embedding 이후 공간 구조가 드러남

• 위치 정보가 들어가면서 “가까운 패치끼리 비슷하게 보는 경향” 같은 구조가 관찰

3. Layer가 깊어질수록 attention distance가 커짐

• 초기층은 근처 패치, 후반층은 먼 패치까지 보며 CNN의 receptive field가 넓어지는 느낌과 유사한 현상

2.4 ViT 한 장 요약(면접용)

• 한 줄: “이미지를 패치 토큰 시퀀스로 바꿔 Transformer Encoder로 분류한다.”
• 장점: 전역 관계를 MHSA로 직접 모델링
• 단점(초기 ViT 관점): CNN bias가 약해 큰 데이터/사전학습 의존도가 큼

3) DETR — “Detection을 Set Prediction으로 바꿔 NMS 제거”

강의에서 “DETI”처럼 들린 건 DETR이 맞습니다. (End-to-End Object Detection with Transformers, ECCV 2020)

3.1 기존 Detection의 골칫거리: 후보 박스가 많아 NMS 필요

• 앵커/후보가 많아 같은 물체에 박스가 여러 개 겹쳐 나옴
• 그래서 후처리로 NMS(Non-Maximum Suppression)로 중복 제거

3.2 DETR의 핵심 아이디어 (Step-by-step)

Step 1) Backbone(CNN)으로 feature map 추출

• ViT처럼 처음부터 패치 토큰화하는 게 아니라,
• CNN으로 feature map을 뽑고 Transformer에 입력

예:

$$ F \in \mathbb{R}^{H' \times W' \times C'} $$

Step 2) feature map을 시퀀스로 펼치고(Flatten), 2D Positional Encoding 추가

• Flatten 후 시퀀스 길이:

$$ L = H'\cdot W' $$

• 펼친 형태(개념):

$$ X \in \mathbb{R}^{L \times C'} $$

• 2D 위치 정보를 유지하기 위해 positional encoding을 더함:

$$ X \leftarrow X + E_{\text{pos}} $$

Step 3) Transformer Encoder로 전역 컨텍스트 통합

• Encoder가 이미지 전체 정보를 통합한 표현을 만든다

Step 4) Decoder에 “Object Queries”를 넣는다 (DETR 감성 핵심)

• 고정 개수 (N_q)개의 학습 가능한 query 벡터

$$ Q \in \mathbb{R}^{N_q \times d_{model}} $$

• 각 query가 “하나의 물체 슬롯”처럼 동작하도록 학습된다

Step 5) 각 query 출력에서 (클래스, 박스) 예측

• 각 query마다 출력:

  • class logits: (K) classes + no-object
  • box: ((c_x, c_y, w, h)) (보통 정규화)

3.3 no-object 클래스는 왜 필요?

고정 개수 query를 쓰면, 이미지에 물체가 2개여도 query는 예를 들어 100개일 수 있습니다.

• 남는 query들은 “아무 물체도 담당하지 않음”이어야 함
• 그래서 no-object 클래스가 필요하다

3.4 NMS를 없애는 핵심 장치: Bipartite Matching + Hungarian Algorithm

핵심 목표

“각 GT(정답 물체)에 예측 query를 1개씩만 매칭하자.” → 그러면 같은 물체를 여러 query가 중복 예측하는 학습이 줄어듦 → NMS 의존이 감소

Step-by-step

1. 예측 (N_q)개와 GT (N_{gt})개의 비용(cost) 행렬 구성
2. 비용 합이 최소가 되는 1:1 매칭을 찾음 (Hungarian Algorithm)
3. 그 매칭 결과로 loss를 계산하고 학습

3.5 DETR Loss를 “직관”으로 이해하기

보통 손실은 다음 두 덩어리로 이해하면 충분합니다.

• Class loss: 각 query가 어떤 클래스인지(or no-object인지)

• Box loss: 박스 좌표가 얼마나 맞는지

  • L1 loss
  • IoU 계열 손실(GIoU 등)을 함께 쓰는 경우가 많음

헝가리안 매칭은 “loss를 최소화하는 1:1 매칭을 고르는 과정”으로 이해하면 정확합니다.

4) ViT vs DETR vs CNN 한 번에 정리

4. Transformer for Time Series (Informer 중심)

0) 이 파트 한 줄 목표

시계열 예측은 입력 길이 (L)이 매우 길어지기 쉬워서 Self-Attention 비용이 $(O($$L^2$$))$ 로 폭증한다. Informer(AAAI 2021) 는 이를 줄이기 위해 중요한 Query만 골라 계산하는 ProbSparse Attention으로 효율을 높여 Long Sequence Forecasting을 가능하게 하려는 모델이다.

1) 용어/발화 오류 교정 (강의 이해 필수)

✅ 중요한 정정 1 — 샘플링 예시 숫자

강의에서 “30초 + 100kHz → 3000개 입력”이라고 했다면 수치가 어긋나 있어요.

• 100kHz = 초당 100,000 샘플
• 30초면:

$$ L = 30 \times 100{,}000 = 3{,}000{,}000 $$

즉 3,000,000개가 맞습니다. “3000개”라는 발화는 실제 의도가 100Hz(초당 100샘플) 정도였을 가능성이 큽니다.

2) 왜 시계열은 Transformer가 힘든가? (핵심 논리 Step-by-step)

Step 1) 시계열은 입력 길이 (L)이 매우 길어지기 쉽다

• 자연어 문장은 보통 수십~수백 토큰
• 센서/로그/계측 데이터는 초당 샘플이 누적되어 수천~수백만 포인트까지 늘어남

Step 2) Self-Attention은 (L\times L) 어텐션 행렬이 생긴다

기본 self-attention은 다음을 계산한다.

$$ A = \mathrm{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right) $$

여기서 (A)의 shape는:

$$ A \in \mathbb{R}^{L \times L} $$

Step 3) 그래서 계산/메모리가 (O(L^2))로 증가한다

예를 들어 (L=3000)이면,

$$ L^2 = 3000 \times 3000 = 9{,}000{,}000 $$

어텐션 행렬만 900만 원소가 된다. 여기에 레이어 수, 헤드 수, 배치 크기까지 곱해지면 시계열에서는 큰 부담이 된다.

3) Informer 핵심 아이디어: “모든 Query를 다 계산하지 말자”

강의의 직관은 다음으로 요약할 수 있다.

3.1 Lazy Query vs Active Query

• Lazy Query: 모든 Key에 대한 attention 분포가 거의 균등(평평) → 계산해도 얻는 정보가 적다
• Active Query: 특정 Key에 attention이 강하게 몰림 → 중요한 상호작용이므로 계산 가치가 크다

Lazy:   [0.02 0.02 0.02 0.02 ...]  (거의 균등)
Active: [0.60 0.20 0.10 0.05 ...]  (특정 키에 집중)

4) ProbSparse Attention: “Active Query만 뽑아서 계산”

4.1 핵심 아이디어

• 전체 Query 중에서 상위 (u)개(활성 Query)만 골라 attention을 계산
• 나머지는 근사/생략하여 비용을 줄인다

강의에서 “Top 6 query” 같은 표현은 보통 다음을 의미한다.

• 전체 Query 중 상위 (u)개만 attention 계산
• (u)는 고정 숫자일 수도 있고, 길이 (L)에 따라 정해질 수도 있음(설계/실험에 따라)

✅ 중요한 정정 2 — “uniform처럼 만들자”가 아니라 “uniform에서 멀수록 중요”

강의에서 “uniform(1/Lk)처럼 만들도록 loss를 준다”처럼 들렸다면 오해가 생길 수 있어요. 이 파트는 보통 아래 흐름으로 이해하는 게 자연스럽습니다.

1. 어떤 Query의 attention 분포가 uniform에 가까우면 (lazy) 정보량이 적다
2. uniform에서 멀수록 (active) 특정 Key에 집중하므로 중요하다
3. 따라서 uniform에서 많이 벗어난 Query를 골라 계산한다

즉 결론은:

“uniform처럼 만들자”가 아니라 “uniform에서 많이 벗어난(active) Query를 골라 계산하자” 가 핵심입니다.

5) Informer 예측 구조: Encoder–Decoder 입력 구성

시계열 예측에서는 디코더 입력을 다음처럼 구성하는 방식이 흔합니다.

5.1 Encoder input / Decoder input

• Encoder input ((X_{enc})): 과거 관측 시계열(긴 구간)

• Decoder input: 두 부분으로 구성

  1. 과거 끝부분 일부(known tail): 실제 관측값 일부를 넣어 시작점을 제공
  2. 미래 구간 placeholder: 예측할 길이만큼 0 또는 마스크 값으로 자리만 확보

5.2 전체 흐름(그림)

flowchart LR
  A[Past series X_enc] --> Enc[Encoder]
  B[Known tail tokens] --> DecIn[Decoder input]
  C[Future placeholders (zeros/mask)] --> DecIn
  Enc --> Dec[Decoder]
  DecIn --> Dec
  Dec --> Yhat[Forecast Y_hat]
  Ytrue[Ground truth future] --> Loss
  Yhat --> Loss

5.3 학습은 어떻게 진행되나?

• 디코더 출력 (\hat{Y})를 실제 미래 (Y)와 비교해 loss(MSE 등)를 최소화하도록 학습

예:

$$ \mathcal{L} = \frac{1}{T}\sum_{t=1}^{T} (Y_t - \hat{Y}_t)^2 $$

핵심은 “긴 시퀀스를 다 보는 대신, 계산할 attention을 줄여 효율을 확보”하는 방향입니다.

6) 차원(shape) 추적 (구현 시 실수 방지)

시퀀스 길이 (L), 모델 차원 (d_{model}), 헤드 차원 (d_k)

Informer는 여기서 모든 Query에 대해 $(L\times L)$ 계산을 하지 않도록 줄이는 게 핵심이다.

5 BERT & GPT

5.1 이 교재 사용법

1. [타임라인 ↔ 슬라이드]로 “지금 강의가 어느 페이지인지” 먼저 잡습니다.
2. 각 파트는 아래 순서로 공부하면 가장 안정적으로 이해가 됩니다.

• 정확 용어/정의(발화 오류 교정 포함)
• 핵심 직관(그림/표로 요약)
• 수식(슬라이드/논문식 형태로 정확 표기 + 의미 해설)
• 면접/실무 답변 템플릿(15초 요약)

5.2 강의 음성 TXT ↔ 슬라이드 싱크 맵 (PDF 페이지 기준)

5.3 강의에서 자주 헷갈린 용어/표현 정정 표

5.4 Part A. 왜 BERT/GPT가 폭발했나 (p2–p4)

5.4.1 강의 핵심 논리 (Step-by-step)

Step 1) NLP는 입력 데이터 (X)가 매우 많다

• 웹/문서/댓글/로그 등 텍스트는 무한히 쌓인다(강의 요지)

Step 2) 하지만 레이블 (Y)를 만들기 어렵다

• 번역/요약/NLI 등은

  • “정답의 정의” 자체가 애매하거나
  • 사람마다 기준이 달라 합의(투표/다수결/가이드라인)가 필요

Step 3) 결론: “레이블 없이도 학습되는 과제”로 먼저 크게 학습한다

• Self-supervised(자기지도) 과제(MLM/다음토큰예측)로 표현을 먼저 학습
• 이후 필요한 태스크에 소량 레이블로 적응(파인튜닝/프롬프트)

5.4.2 (p4) “NLP vs Bio/CV”가 말하는 진짜 포인트

5.5 Part B. Pretrain → Finetune / Transfer / Few-shot·Zero-shot (p5–p10)

5.5.1 (p5) CV 예시로 이해하는 “프리트레인–파인튜닝”

강의의 “로우레벨/하이레벨 필터”를 NLP로 대응하면:

• 로우레벨: 기본 문법/표현/일반 문맥 패턴(범용)
• 하이레벨: 특정 태스크(감성/QA/NER/분류)에 맞는 결정 경계(특화)

파라미터 고정(Freeze) 직관

[Pretrained Backbone]
Layer1  (freeze)  <- 범용 패턴
Layer2  (freeze)
Layer3  (train)   <- 타겟 태스크에 맞게 조정
Head    (train)   <- 태스크 출력층

실무 팁: 데이터가 적을수록 “하단 레이어 freeze + 상단만 학습”이 안정적인 출발점입니다.

5.5.2 (p6) Transfer learning vs Finetuning 정리

5.5.3 (p7) Few-shot / One-shot / Zero-shot (NLP 프롬프트로 정확 대응)

정의(시험/면접)

• Zero-shot: 예시 0개
• One-shot: 예시 1개
• Few-shot: 예시 (k)개

NLP 구현(강의 “번역 원샷”을 정확 프롬프트로)

[예시(1-shot)]
한국어: 나는 배고프다
영어: I am hungry

[문제]
한국어: 오늘 날씨가 좋다
영어:

핵심:

• 파라미터 업데이트(gradient update) 없이
• 프롬프트(지시 + 예시 + 질의)만으로 조건부 생성을 수행

5.5.4 (p8–p10) Domain/러닝 패러다임 혼동 방지(필수 2개)

(1) Domain이란?

도메인 (D)는 보통 데이터가 생성/샘플링되는 분포(환경)를 의미합니다.

(2) Transfer vs (In-context) Zero/Few-shot을 가르는 가장 쉬운 기준

• Transfer(파인튜닝 포함): 타겟 데이터로 파라미터 업데이트 있음
• Zero/Few-shot(in-context): 프롬프트에 예시가 있을 뿐 파라미터 업데이트 없음

5.6 Part C. GPT-1 (p11–p19) — Generative Pre-Training + Fine-tuning

5.6.1 (p11) GPT-1 큰 그림

• GPT = Generative Pre-Training
• 철학: (1) LM으로 먼저 크게 학습 → (2) 태스크별로 약간만 맞춤

flowchart LR
  A[Large unlabeled text] --> B[Stage 1: LM Pretraining]
  B --> C[Transformer Decoder (shared)]
  D[Labeled dataset per task] --> E[Stage 2: Supervised fine-tuning]
  C --> E
  E --> F[Downstream performance]

5.6.2 (p14) Stage 1: Causal Language Modeling 수식(정확 표기)

토큰 시퀀스를 (U=(u_1,\dots,u_n))라 할 때, GPT의 언어모델은 과거 토큰만 조건으로 다음 토큰을 예측합니다.

(1) 최대화 관점(로그우도)

[ \max_{\theta}\ \sum_{i=1}^{n}\log P(u_i \mid u_{<i};\theta) ]

(2) 손실(최소화) 관점(음의 로그우도)

[ L_{\text{LM}}(\theta) =====================

-\sum_{i=1}^{n}\log P(u_i \mid u_{<i};\theta) ]

강의의 “레프트-투-라이트(미래 못 봄)”는 (u_{<i})만 쓰는 조건부 확률을 뜻합니다.

5.6.3 (p15) Stage 2: Supervised Fine-tuning + LM 보조항

타겟 태스크 데이터 (C)가 ((x,y)) 쌍의 집합일 때:

(1) 태스크 손실(예: 분류)

[ L_{\text{task}}(\theta) =======================

-\sum_{(x,y)\in C}\log P(y\mid x;\theta) ]

(2) 최종 손실(슬라이드의 (\lambda) 결합을 “손실 형태로” 정확히)

[ L(\theta) =========

L_{\text{task}}(\theta) + \lambda\ L_{\text{LM}}(\theta) ]

• (\lambda)가 작은 이유(강의 의도):

  • 태스크 성능에 집중하되
  • LM 일반성(표현)을 조금 유지해 과적합 완화에 도움

5.6.4 (p16) “입력 구조만 바꾸면 다양한 태스크에 적용”의 의미

모델(디코더 트랜스포머)은 그대로 두고, 태스크 입력을 텍스트 시퀀스로 ‘포맷팅’합니다.

5.6.5 (p17–p19) Ablation 요지(강의 포인트 유지)

• 프리트레인(LM) + 파인튜닝 조합이 성능에 기여
• 모델 깊이/규모 증가가 성능을 밀어올림
• LSTM 대비 Transformer가 여러 태스크에서 더 강한 경향

5.7 Part D. BERT (p20–p35) — Bidirectional Encoder + MLM(+NSP)

5.7.1 (p21–p23) GPT vs BERT 구조 차이(핵심 1줄)

• GPT: Decoder + Causal(미래 마스킹) → 생성에 유리
• BERT: Encoder + Bidirectional(좌/우 문맥) → 이해/표현학습에 유리

GPT (Causal):
t3는 (t1,t2)만 봄, (t4,t5)는 마스킹

BERT (Bidirectional):
t3는 (t1,t2,t4,t5) 모두 볼 수 있음
(단, MLM에서는 일부 토큰이 [MASK]로 가려짐)

5.7.2 (p24–p26) Pretrain 1: Masked Language Model(MLM)

목적

입력 토큰 일부를 가리고, 가려진 토큰을 맞추며 양방향 문맥 표현을 학습합니다.

마스크 위치 집합을 (M)이라 할 때:

[ L_{\text{MLM}}(\theta) ======================

-\sum_{i\in M}\log P(x_i \mid x_{\backslash M};\theta) ]

80/10/10 규칙(강의 싱크 강함)

마스크 후보로 뽑힌 토큰(보통 전체의 15% 내외)에 대해:

• 80% → [MASK]로 치환
• 10% → 랜덤 토큰으로 치환
• 10% → 원래 토큰 유지

이유

• 파인튜닝/추론에서는 [MASK]가 없을 수 있으므로 [MASK]에만 과적응하는 것을 방지

5.7.3 (p27) Pretrain 2: Next Sentence Prediction(NSP)

두 문장 A, B가 주어졌을 때:

• IsNext: 실제 코퍼스에서 A 다음에 B가 이어짐
• NotNext: B를 다른 문서/문맥에서 랜덤 샘플

목표는: [ L_{\text{NSP}}(\theta) ======================

-\sum \log P(\text{label} \mid A,B;\theta) ]

강의 기준에서는 NSP를 핵심 구성으로 설명하므로 그대로 따라가면 됩니다.

5.7.4 (p28) BERT 입력 임베딩 3종 합(시험 단골)

토큰 위치 (i)에서 최종 입력 임베딩:

[ \mathbf{e}_i ============

\mathbf{e}^{token}_i + \mathbf{e}^{pos}_i + \mathbf{e}^{segment}_i ]

• (\mathbf{e}^{token}): 토큰 의미(서브워드)
• (\mathbf{e}^{pos}): 위치 정보
• (\mathbf{e}^{segment}): 문장 A/B 구분(문장쌍 입력)

5.7.5 (p29) Fine-tuning 패턴 2가지(문장 단위 vs 토큰 단위)

(1) Sequence-level(문장/문장쌍 분류)

• [CLS] 출력 벡터 (\mathbf{h}_{CLS}) → 분류기 → label

[ \hat{y}=\text{softmax}(W\mathbf{h}_{CLS}+b) ]

(2) Token-level / Span-level

• NER: 각 토큰 벡터 (\mathbf{h}_i)에 분류기
• SQuAD(QA): start/end 위치 예측

SQuAD 스팬 점수화(강의의 dot product를 수식으로 정리)

[ \text{score}{start}(i)=\mathbf{h}*i^\top \mathbf{s},\quad \text{score}{end}(i)=\mathbf{h}i^\top \mathbf{e} ] [ P(start=i)=\text{softmax}(\text{score}{start}),\quad P(end=i)=\text{softmax}(\text{score}*{end}) ]

5.7.6 (p30–p33) 벤치마크가 의미하는 것(강의 흐름 유지)

5.7.7 (p34–p35) Ablation 해석(강의 요지 그대로)

• 당시 설정에서는 MLM/NSP가 성능에 기여
• 특히 MLM이 “문맥 표현”을 강하게 밀어줌

5.8 Part E. GPT-2 (p36–p44) — 더 큰 데이터 + BPE + Zero-shot

5.8.1 (p36–p38) GPT-2가 강조한 3가지

1. 더 큰 데이터(WebText 등)로 LM 학습
2. 스케일(모델/데이터) 증가
3. 파인튜닝 없이도(혹은 최소화) zero-shot 성능을 보여줄 수 있다

5.8.2 (p39–p43) BPE(Byte Pair Encoding) — 완전 정리

왜 필요한가?

• 단어 단위 토크나이징은 OOV(사전에 없는 단어)가 빈번
• 서브워드(BPE/WordPiece 등)를 쓰면 “처음 보는 단어”도 분해/조합 가능

BPE 알고리즘(정확 Step-by-step)

1. 초기 vocabulary를 문자(또는 바이트) 단위로 시작
2. 말뭉치에서 가장 빈번한 연속 pair를 찾음
3. 그 pair를 merge하여 하나의 토큰으로 추가
4. 목표 vocab 크기까지 반복

강의의 “트위터 이모지” 맥락은, byte-level 계열 토크나이징이 특수문자/이모지 처리에 유리하다는 직관으로 이해하면 됩니다.

5.8.3 (p36–p44) Zero-shot 프롬프트화(강의 요지)

• 분류 문제도 “라벨을 출력 토큰으로 생성”하는 형태로 바꿔서 수행 가능
• 즉, 헤드(softmax classifier)를 학습하지 않고 프롬프트로 태스크를 기술

5.9 Part F. GPT-3 (p45–p49) — 스케일 + In-context learning

5.9.1 (p45) GPT-3 핵심 메시지(강의 표현 그대로)

• GPT-2 철학을 확장: 더 큰 모델 + 더 큰 데이터 → 더 강한 일반화
• 프롬프트에 예시를 넣어 zero/one/few-shot 수행
• 중요한 포인트: gradient update 없이(학습 없이) 추론에서 해결

5.9.2 In-context learning 흐름(도식)

flowchart LR
  A[Instruction: task description] --> M[Pretrained GPT]
  B[Examples: (x1->y1)...(xk->yk)] --> M
  C[Query: x?] --> M
  M --> D[Generated answer y?]

5.9.3 (p49) 강의 요약을 “한 줄”로

• BERT: 문장을 “이해/표현”하는 데 강한 인코더
• GPT: 문장을 “생성/연속 예측”하는 데 강한 디코더

5.10 Part G. 실무/연구 동향 (강의 위에 최소 확장)

5.10.1 PEFT(예: LoRA) — “가볍게 적응시키는 파인튜닝”

• 대형 모델 전체를 업데이트하면 비용/메모리가 큼
• 그래서 일부 저랭크 어댑터만 학습해 빠르게 적응
• 대표: LoRA (arXiv:2106.09685)

면접용 한 줄

• “요즘은 full fine-tuning 대신 LoRA 같은 PEFT로 비용을 줄이고 빠르게 도메인 적응한다.”

5.10.2 RAG — “모르는 지식은 검색으로 보강”

• 모델 파라미터에 지식을 ‘다’ 넣기보다 검색으로 관련 문서(근거)를 가져와 생성에 결합
• 대표 개념 정리로 널리 인용되는 축: RAG (arXiv:2005.11401)

면접용 한 줄

• “최신/사내 지식과 근거가 필요하면 RAG로 문서를 붙여 환각을 줄인다.”

5.11 Part H. (시험/면접 대비) 15초 답변 템플릿 6개

5.11.1 왜 프리트레인이 필요한가?

“자연어는 입력 데이터는 많지만 레이블이 만들기 어려워서, 자기지도 과제로 대규모 사전학습을 하고 소량의 레이블로 다운스트림 태스크에 적응시키는 프리트레인–파인튜닝 전략이 강해졌습니다.”

5.11.2 GPT와 BERT의 구조 차이?

“GPT는 디코더 기반 causal LM이라 과거만 보고 다음 토큰을 생성하고, BERT는 인코더 기반 양방향 self-attention으로 좌우 문맥을 함께 보며 표현을 학습합니다.”

5.11.3 GPT-1의 2-stage는?

“1단계에서 언레이블 텍스트로 LM을 프리트레인하고, 2단계에서 태스크 레이블로 파인튜닝하며 필요하면 LM 손실을 (\lambda)로 섞어 일반성을 유지합니다.”

5.11.4 BERT의 MLM 80/10/10 이유?

“추론 때 [MASK]가 없으므로 [MASK]에 과적응하지 않게 랜덤/원토큰을 섞어 견고한 문맥 표현을 학습합니다.”

5.11.5 Zero-shot/Few-shot의 핵심?

“파라미터 업데이트 없이, 프롬프트에 지시문과 예시를 넣어 조건부 생성으로 태스크를 수행하는 방식입니다.”

5.11.6 요즘 현업 파인튜닝/운영 흐름?

“대형 모델은 LoRA 같은 PEFT로 일부만 학습해 비용을 줄이고, 최신 지식/근거가 필요하면 RAG로 검색 문서를 결합합니다.”

5.12 Part I. 연습문제 + 채점 기준

5.12.1 개념 퀴즈 8문항

1. (p4) 자연어에서 “레이블링이 어렵다”는 말이 의미하는 두 가지를 쓰시오.
2. (p5) 프리트레인–파인튜닝에서 freeze를 하는 이유를 데이터 크기 관점에서 설명하시오.
3. (p7) zero-shot과 transfer learning을 구분하는 가장 쉬운 기준은?
4. (p14) GPT의 Causal LM은 어떤 조건부 확률을 최대화하는가?
5. (p15) (L=L_{\text{task}}+\lambda L_{\text{LM}})에서 (\lambda)를 작게 두는 직관은?
6. (p28) BERT 입력 임베딩 3종과 역할을 각각 쓰시오.
7. (p29) SQuAD에서 start/end를 예측하는 점수화는 어떤 형태인가?
8. (p39–p43) BPE가 OOV를 줄이는 원리를 2~3줄로 설명하시오.

5.12.2 채점 기준(핵심만)

• 3번: 파라미터 업데이트 유무를 말하면 정답
• 5번: “태스크에 집중하면서도 LM 일반성을 조금 유지(과적합 완화)”면 정답
• 7번: “각 토큰 벡터와 start/end 벡터의 dot product(선형 점수) 후 softmax”면 정답

6. Hugging Face Library

아래는 네가 정리해둔 실습 코드를 교재형으로 “형식/수식(표기)/코드(실행가능)”까지 통일해서, 앞뒤 흐름이 끊기지 않게 다시 엮은 최종본이야. (마지막에 바로 실행 가능한 .ipynb / .py 파일도 같이 줌)

6.1 이 장의 목표

6.1.1 우리가 “정확히” 하려는 것

1. pipeline()으로 즉시 추론(inference) 하기
2. AutoTokenizer로 토큰화 → id 변환 → 텐서 입력 흐름 이해하기
3. datasets.load_dataset()로 TSV/JSON 데이터 로드하기
4. map()으로 전처리(예: HTML unescape) 하기
5. PyTorch로 학습 루프(training loop) + scheduler까지 최소 단위로 돌려보기

6.2 실습 준비

6.2.1 설치(로컬/코랩 공통)

pip install -U transformers datasets accelerate torch tqdm

6.2.2 디바이스 선택(공통)

• GPU가 있으면 cuda, 없으면 cpu

import torch
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

6.3 Pipeline 빠른 시작

6.3.1 Pipeline이 해주는 일(한 줄 정의)

pipeline(task)는 내부적으로 아래를 자동으로 묶어준다.

[ \text{pipeline} = \text{Tokenizer} \circ \text{Model} \circ \text{PostProcess} ]

즉, 토크나이징 → 모델 forward → 후처리(확률/디코딩) 까지 “한 방”에 처리한다.

6.3.2 (실습 1) fill-mask

from transformers import pipeline

unmasker = pipeline("fill-mask")
unmasker("This course will teach you all about <mask> models", top_k=2)

핵심 포인트

• 문장 안에 <mask>를 넣으면, pipeline이 해당 모델의 mask 토큰으로 맞춰서 처리한다.
• 재현성을 올리려면 모델을 명시하는 게 좋다:

unmasker = pipeline("fill-mask", model="bert-base-uncased")

6.3.3 (실습 2) sentiment-analysis (docx 텍스트 코드 반영)

from transformers import AutoTokenizer, pipeline

model_name = "klue/roberta-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
classifier = pipeline("sentiment-analysis", model=model_name, tokenizer=tokenizer)

classifier("이 강의 진짜 도움 많이 됐어요!")

6.4 Tokenizer → id → Model 입력

6.4.1 토크나이저의 역할(정확 정의)

텍스트 (x)가 들어오면, 모델이 먹을 수 있는 텐서 묶음으로 변환한다.

[ x ;\rightarrow; {\text{input_ids},;\text{attention_mask},;\text{token_type_ids(optional)}} ]

• input_ids: 토큰 id 시퀀스
• attention_mask: 패딩(0) vs 실제 토큰(1)
• token_type_ids: 문장쌍(A/B) 구분(BERT류에서 주로 사용)

6.4.2 (실습 3) docx 이미지 예시 그대로 + 실패 라인 유지

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
input_ids = torch.tensor(ids)

# This line will fail.
model(input_ids)

왜 실패하나? (원인 “정확히”)

대부분의 Transformer 모델 입력은 배치 차원(batch dimension) 을 기대한다.

• 지금 input_ids shape: [ (seq_len,) ]
• 모델이 기대하는 기본 shape: [ (batch,;seq_len) ]

6.4.3 Fix(실행되게 만들기): 배치 차원 추가

input_ids = torch.tensor([ids])   # (batch, seq_len)
model(input_ids)

6.4.4 실무/실습에서 “정석”(추천): tokenizer가 바로 텐서 만들게 하기

이게 제일 덜 틀리고, attention_mask도 자동으로 들어가서 안정적이다.

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)

sequence = "I've been waiting for a HuggingFace course my whole life."

inputs = tokenizer(sequence, return_tensors="pt")  # dict of tensors
outputs = model(**inputs)

logits = outputs.logits                    # (batch, num_labels)
pred = logits.argmax(dim=-1).item()

print("pred:", pred, "label:", model.config.id2label[pred])

출력 텐서 shape(시험/디버깅 핵심)

• 분류 모델이면:

[ \text{logits shape} = (batch,;num_labels) ]

6.5 Tokenizer 내부 구조(backend_tokenizer) + normalizer

6.5.1 왜 보나?

• “토큰화가 내부에서 어떻게 동작하는지”를 실제로 확인하는 용도
• 특히 normalize_str는 악센트/특수문자 정규화 같은 전처리 감각을 잡기 좋다.

6.5.2 (실습 4) backend_tokenizer + normalizer

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
print(type(tokenizer.backend_tokenizer))

print(tokenizer.backend_tokenizer.normalizer.normalize_str("Héllò hôw are ü?"))

6.6 Datasets 로드

6.6.1 TSV 로드(drugsCom 예시)

from datasets import load_dataset

data_files = {"train": "drugsComTrain_raw.tsv", "test": "drugsComTest_raw.tsv"}
drug_dataset = load_dataset("csv", data_files=data_files, delimiter="\t")

빠른 확인

drug_dataset["train"]["condition"][:3]

6.6.2 JSON 로드(SQuAD_it 예시)

from datasets import load_dataset

data_files = {"train": "SQuAD_it-train.json", "test": "SQuAD_it-test.json"}
squad_it_dataset = load_dataset("json", data_files=data_files, field="data")

샘플 1개 확인:

squad_it_dataset["train"][0]

6.6.3 단일 JSON 로드(일반형)

from datasets import load_dataset
load_dataset("json", data_files="myfile.json")

6.7 map()으로 전처리(HTML unescape)

6.7.1 목적

리뷰 텍스트에 &, " 같은 HTML 엔티티가 남아있으면 모델 입력이 지저분해진다. html.unescape로 정리한다.

6.7.2 (실습 5) batched map 적용

import html

new_drug_dataset = drug_dataset.map(
    lambda x: {"review": [html.unescape(o) for o in x["review"]]},
    batched=True,
)
new_drug_dataset

핵심 포인트

• batched=True면 x["review"]가 리스트 단위로 들어오므로, 리스트를 리턴해야 한다.

• 실무에서는 이후에 보통:

  • remove_columns
  • rename_column("label", "labels")
  • set_format("torch") 같은 정리 루틴이 붙는다.

6.8 Training loop (tqdm) + Scheduler

6.8.1 학습 루프가 하는 일(정확 구조)

각 스텝에서:

1. 배치 텐서를 디바이스로 이동
2. forward: ( \hat{y} = f_\theta(x) )
3. loss 계산 (보통 Cross Entropy)
4. backward: ( \nabla_\theta L )
5. optimizer step
6. scheduler step
7. grad reset

분류의 표준 loss는:

[ L = -\sum_{c} y_c \log(\text{softmax}(\text{logits})_c) ]

6.8.2 (실습 6) 진행바 포함 training loop (네 코드 흐름 그대로)

from tqdm import tqdm

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

6.8.3 (실습 7) get_scheduler로 LR Scheduler 만들기

from transformers import get_scheduler

num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)
print(num_training_steps)

linear 스케줄 직관

• 학습이 진행될수록 LR을 선형으로 줄이는 형태
• warmup을 쓰면 초반엔 LR을 점점 올린 뒤, 이후 감소

6.9 실습에서 제일 많이 터지는 오류 TOP 6 (바로 해결형)

1. 배치 차원 누락

   • 해결: torch.tensor([ids]) 또는 tokenizer(..., return_tensors="pt")

2. attention_mask 없음

   • 해결: 수동 입력 말고 tokenizer() 출력 dict 사용

3. 모델/토크나이저 mismatch

   • 해결: 같은 checkpoint로 둘 다 로드

4. fill-mask에서 마스크 토큰 혼동

   • 해결: pipeline에는 <mask> 쓰면 안전, 직접이면 tokenizer.mask_token 확인

5. datasets.map에서 batched 처리 실수

   • 해결: batched면 리스트를 리턴해야 함

6. GPU 사용 시 device 인자 미지정

   • 해결: pipeline은 device=0, torch는 .to(device)

6.10 바로 실행 가능한 파일

• Download the Notebook
• Download the Python script

원하면 다음 단계로 HuggingFace실습.docx 이미지들을 “이미지 번호별 → 코드 셀로 정렬 → 중복 제거 → 실행 순서로 재배치” 해서, docx 전체를 1개의 완성 노트북으로 합치는 버전도 바로 만들어줄게.

title: 한국 바다낚시 완전정리 – 1~12월 서해·남해·동해 / 원투·메탈·다운샷·선상 기준 tags: [바다낚시, 원투낚시, 메탈지그, 다운샷, 선상낚시, 서해, 남해, 동해, 물때, 월별정리]

한국 바다낚시 연간 정리

(1~12월 / 서해·남해·동해 / 원투·메탈·다운샷·선상 기준)

대한민국은 4계절 뚜렷하고 3면이 바다인 미친(?) 나라다.
그래서 “언제, 어느 바다(서해/남해/동해), 어떤 낚시(원투/메탈/다운샷/선상)로, 어떤 물고기를, 어느 물때에 노려야 하는지” 를 한 번에 볼 수 있게 정리했다.

⚠️ 이 정리는 찌낚시(찌·카고·구멍찌 등) 를 전부 제외하고
원투 / 메탈루어 / 다운샷 / 선상 네 가지만 기준으로 한다.

1. 이 글에서 다루는 낚시 스타일

• 원투낚시

  • 갯바위, 방파제, 방조제, 해변(서프)
  • 타깃: 광어, 도다리, 도다리, 우럭, 장어, 고등어, 전갱이, 전어 등

• 메탈 루어 낚시

  • 메탈지그, 스틱베이트, 다이빙펜슬, 탑워터 등
  • 타깃: 삼치, 방어/부시리, 고등어, 전갱이, 농어, 광어 등

• 다운샷 루어 낚시

  • 바닥 찍고 살살 끌어오는 스타일
  • 타깃: 광어, 도다리, 우럭, 노래미, 무늬오징어(응용) 등

• 선상 낚시

  • 선상 지깅, 캐스팅, 다운샷, 타이러버, 에깅 등
  • 타깃: 광어, 도다리, 우럭, 방어/부시리, 삼치, 참돔, 한치, 갈치, 주꾸미·갑오징어 등

2. 연중 시즌 흐름 & 물때 기본 감각

2-1. 연중 대략 흐름

• 1~3월 (겨울 끝 / 초봄)

  • 수온 낮음 → 우럭·볼락·노래미·광어 일부 위주
  • 선상: 광어 다운샷, 우럭지깅, 동해 대구

• 4~6월 (봄 ~ 초여름)

  • 도다리·광어 산란 시즌(3~4월 피크) → 다운샷/원투 메인
  • 농어, 고등어, 전갱이 슬슬 붙기 시작

• 7~9월 (여름 ~ 초가을)

  • 고등어, 전갱이, 전어, 학공치, 갈치, 한치, 무늬오징어 등 회유성 어종 폭발
  • 동해/남해: 삼치·부시리(방어급) 메탈·지깅·캐스팅 시즌

• 10~12월 (가을 ~ 초겨울)

  • 광어·도다리·우럭·볼락 활성
  • 남해/제주/부산·거제 외해 기준
    방어·부시리 빅게임 11~2월 피크

2-2. 물때 기본 룰 (대략적인 가이드)

• 광어·도다리·우럭 (다운샷/원투)

  • 3~7물 : 조류 적당 → 채비 컨트롤 + 입질 둘 다 괜찮은 구간

• 삼치·방어·부시리·고등어·전갱이 (메탈/선상)

  • 5~8물 : 조류가 어느 정도 흘러야 떼가 붙고 활성도 좋음
  • 너무 사리(9~10물)면 채비 컨트롤이 빡세니, 포인트/수심 보고 선택

• 주꾸미·갑오징어 (특히 서해)

  • 25물 정도의 약중조류
  • 에기 컨트롤 편하고, 초보도 하기 쉬운 구간

• 볼락·노래미·장어 (원투/루어)

  • 조류가 너무 세지 않은 14물, 810물
  • 야간에 물 흐름 살짝 있는 정도가 이상적

3. 서해 – 1~12월 / 원투·메탈·다운샷·선상 정리

기준: 인천·시화방조제·대부도·충남·군산·격포 등 서해 전역 공통적인 패턴을
“월별 + 기법 + 어종 + 물때” 로 요약한 표.

3-1. 서해 월별 한눈에 보기

4. 남해 – 1~12월 / 원투·메탈·다운샷·선상 정리

기준: 부산·거제·통영·여수·완도 등 남해 전역 공통 패턴.
어종 다양성 미친 지역이라 필요 이상으로 다 잡히는 곳.

4-1. 남해 월별 한눈에 보기

5. 동해 – 1~12월 / 원투·메탈·다운샷·선상 정리

기준: 포항·울산·삼척·속초 등 동해 전역 공통 패턴.
특징: 수심이 빠르게 깊어지고, 삼치·부시리·대구 등 “동해스러운” 어종이 강함.

5-1. 동해 월별 한눈에 보기

6. 이 표를 실제로 활용하는 방법

6-1. 타깃 어종 먼저 고르기

예를 들어,

• “12월 방어·부시리 + 광어” 가 목표라면
  → 남해(부산·거제·통영) & 제주 외해, 동해 남부 외해 위주
  → 위 표에서 남해/동해 11~2월 줄 집중 체크

• “4월 도다리 위주 + 광어 서브”
  → 서해·남해 전역 도다리 산란기 / 다운샷·원투 위주
  → 서해/남해 3~4월 줄만 골라 보면 일정이 바로 나온다.

6-2. 내가 좋아하는 낚시 기법만 필터링하기

• 글에서 다루는 기법:
  • 원투 / 메탈 / 다운샷 / 선상
• 본인이 실제로 즐기는 1~2개만 고르면 됨
  • 예: “메탈 + 선상”만 보는 식으로, 나머지 열은 그냥 참고용

6-3. 물때 고르는 기준 요약

• 삼치·방어·부시리·고등어·전갱이(메탈/지깅)
  → 5~8물: 조류가 어느 정도 흘러줘야 활성도 Good

• 광어·도다리·우럭(다운샷/원투)
  → 3~7물: 바닥 찍기 편하고 입질 잘 들어오는 구간

• 장어·볼락·노래미
  → 14물 또는 810물: 너무 세지 않은 느린 조류 + 야간

• 주꾸미·갑오징어
  → 2~5물: 에기 컨트롤 쉬운 구간

7. 마무리 – “직장인 모드”로 낚시 계획 세우기

1. 월 & 어종 선택

   • “언제 시간이 비는지” → 가능한 월 체크
   • 그 달에 잘 나오는 어종을 표에서 먼저 고른다.

2. 지역 선택 (서해 vs 남해 vs 동해)

   • 거리, 숙소, 이동시간 고려
   • 방어·부시리면 남해/제주·동해,
     도다리·광어면 서해/남해,
     삼치·부시리 메탈이면 동해/남해 쪽으로 좁힌다.

3. 기법 선택

   • 원투 / 메탈 / 다운샷 / 선상 중에서
     이번 출조의 “컨셉”을 하나 정한다.

4. 물때 & 세부 일정

   • 위 표의 추천 물때 (대부분 3~8물 사이)에서
     본인 스케줄 가능한 날을 골라서 맞춘다.
   • 마지막으로 기상(바람·파고), 최근 조황, 금어기만 한 번 더 체크하면
     실패 확률을 꽤 많이 줄일 수 있다.

이 글은 “찌낚시를 제외하고, 원투·메탈·다운샷·선상만으로 한국 바다 1년을 정리한 캘린더”라고 보면 된다.
필요하면 다음 글에서

• “삼치/방어/광어만 따로 뽑은 전용 캘린더”
• “월별·바다별 추천 포인트 예시(포항 뜬방, 오륙도, 조도 등)”

같은 식으로 더 파고들 수 있다.

• Deployment(+HPA)

  • 성격: 상시 처리(큐 워커, 이벤트 소비).
  • 요구: at-least-once 전제, 재시도/내구성, 수평 확장.
  • 의미: 종료코드 143(TERM)은 롤링 등 “정상”일 확률↑ → 알림에서 노이즈 제거.

• Job

  • 성격: 끝이 있는 배치(백필, 리인덱스, 마이그). 완료 후 자원 0.
  • 핵심: completions/parallelism로 작업량·동시성 제어, Indexed로 샤딩/추적.
  • 정책: 실패 분류(podFailurePolicy), TTL 청소로 누적 방지.

• CronJob

  • 성격: 스케줄러(백업, 청소, 리포트).
  • 핵심: 겹침 방지(concurrencyPolicy) + 놓친 스케줄 보전(startingDeadlineSeconds) + 타임존.
  • 정책: 성공/실패 히스토리 제한 + TTL로 “작업 쓰레기” 제어.

2) 필수 파라미터의 “의미”

• concurrencyPolicy (Forbid/Replace/Allow)

  • 재진입 불가 작업이면 Forbid(중복 처리 차단), 최신만 중요하면 Replace.

• startingDeadlineSeconds

  • 컨트롤플레인/스케줄 지연 시 놓친 실행을 보전. 없으면 통째로 건너뜀.

• completionMode: Indexed (Job)

  • 각 완료 인덱스를 고유 샤드로 간주 → 누가 무엇을 처리했는지 추적 가능.

• backoffLimit / activeDeadlineSeconds

  • 재시도 한계/전체 시간 한계로 무한 재시도·좀비 작업 방지.

• ttlSecondsAfterFinished

  • 완료 리소스 자동 정리(운영 디폴트로 활성 가정).

• resources(requests/limits)

  • OOM/Evict 예방의 1순위. 긴 작업은 체크포인트로 재시작 가능 설계.

• topologySpreadConstraints / priorityClassName

  • 배치 분산/중요도 보장(노드 한쪽 치우침·자원 쟁탈 완화).

• timeZone (CronJob)

  • 운영 타임존과 스케줄 혼선 제거(Asia/Seoul 명시).

3) 장애/운영 인사이트

• 중복 실행의 진짜 비용: 재처리·데이터 이중 반영·다운스트림 폭발 → CronJob 겹침 방지가 가장 빠른 보험.
• 스케줄 유실의 진짜 원인: 컨트롤플레인 이벤트 로스·스케줄 지연 → startingDeadlineSeconds로 회복 탄력 확보.
• 배치 실패의 분류 필요성: OOM/스케줄 불가/일시적 디스크압박 등 원인별 대응이 달라짐 → podFailurePolicy로 즉시 Fail/무시/재시도 분기.
• 운영 쓰레기 누적: Job/CronJob은 기본적으로 잔해가 남음 → TTL/HistoryLimit로 SRE 위생 유지.

4) 종료코드의 해석과 앱 행동

• 0: 정상 완료(Completed).

• 143(=128+SIGTERM): 롤링/스케일다운/드레인 등 정상 시나리오에서 흔함.

  • 대응: 배포 이벤트가 있는 윈도우에선 알림 제외(노이즈 컷).

• 137(=128+SIGKILL): Grace 초과 또는 OOMKilled.

  • 대응: terminationGracePeriodSeconds 상향 + preStop 훅으로 우아한 종료, 또는 리소스 증설/메모리 튜닝.

• 앱 관점 가이드

  • SIGTERM 핸들러: 현재 작업 체크포인트/재큐 → Deployment 워커는 exit 0로 빠르게 교체; Job 워커는 미완료면 non-zero로 재시도 유도(단, 안전 재큐 시 0 허용).
  • 블로킹 호출: 타임아웃·주기적 TERM 체크 필수.

5) 관측성 최소 셋

• 라벨/추적키: jobId, commitSha, shardIndex(Indexed) → 문제 재현·영향도 파악 단축.

• 진행률/하트비트: 장시간 작업은 하트비트 파일/키 + 커맨드형 liveness로 “멈춤”을 신호화.

• 메트릭: 완료/실패/재시도 카운트, 실행시간 히스토그램(또는 로그 집계라도).

• 알림 룰:

  • 롤링 중 143은 정상으로 취급(윈도우 제한).
  • OOMKilled는 항상 경고/심각.

6) Redis로 직접 at-least-once 큐 만들 때의 본질

• 수신/확인 분리: BRPOPLPUSH queue → inprogress로 유실 방지(워커 크래시 시 inprogress 스캔).

• 하트비트: 처리 중 task:<id>.lastBeat 갱신 → Reaper CronJob이 타임아웃 항목을 원 큐로 복원.

• 종료 시맨틱:

  • Deployment 워커: 재큐 후 0(교체 신속).
  • Job 워커: 미완료면 non-zero로 컨트롤러 재시도.

7) GitOps에서 안전장치의 위치

• 폴더 = 네임스페이스 바인딩(하드코딩 금지, 파이프라인에서 주입).
• 공통 패치로 기본 가드 주입: ttlSecondsAfterFinished, backoffLimit, activeDeadlineSeconds(Kustomize/Helm).
• 드리프트 억제: kubectl diff / server-side apply / prune.
• HistoryLimit로 컨트롤러 히스토리 관리(관측성 + 청결 균형).

현업에서 가장 효과 큰 5가지

1. CronJob 겹침 방지 안 하면 데이터 이중처리 난리 난다.
2. startingDeadlineSeconds 없으면 스케줄 유실이 “조용히” 지나간다.
3. Job Indexed는 대규모 배치 추적/리트라이 단위의 사실상 표준.
4. TTL + HistoryLimit로 잡 잔해를 자동 청소하라.
5. 143은 정상, 137은 위험 신호—알림 룰을 분리하라.

• 블로그 글1

1인칭 슈팅을 만들거고 TPS 형식으로 만들어 볼 것.

그러기 위해선 마우스의 좌표를 받아서 회전하게끔 수정.

edit에서 회전을 담당할 Mouse X, Y를 설정

만약 Use Controller Rotation Pitch를 활성화하면 아래와 같이, 플레이어가 이상하게 회전한다.

일반적인 TPS게임이면 회전하는 것은 맞는데 위로 볼 때, 캐릭터가 저런식으로 회전하는 것이 아니라 카메라가 그 쪽을 주시하고, 조준하는 총만 위로 올리는 개념이여야 한다. 플레이어 자체가 움직이진 않는다.

그럼 다시 Pawn의 Use Controller Rotation Pitch를 비활성화하고,

Spring Arm을 보면 Pawn Control Rotation을 사용하겠다는 옵션이 있다.

활성화를 해주고, 그럼 플레이어 자체가 회전하는 것이 아니라, 카메라가 플레이어의 회전 값에 맞춰 회전하게 된다.

아래의 코드를 Player 안에다 입력 코드를 작성했는데, 틀린 방법은 아니다. 하지만 만약 플레이어의 코드량이 많아진다거나 아니면 특정 상황에 따라서 행동이 바뀌기를 원하면 플레이어에서 제어하기 보다는 플레이어의 입력을 케어하는 코드이기 때문에, Player Controller에다 넣는 것도 하나의 방법이다.

Player Controller로 이전한 코드

그리고, Jump를 구현해야 한다고 하면 다른 엔진의 경우는 물리공식을 이용하는 등 직접 구현해야 되겠지만, 이 Movement Component에 다양한 기능이 들어가 있다. 언리얼 엔진의 슈팅 게임에 맞춰져있는 엔진이라서 Jump라던지 기어가는 거라던지 기본적인 동작에 대한 함수가 미리 만들어져있다.

예시

-블로그 글 2

BP_PlayerController 생성

Blueprint Class - Player Controller - BP_PlayerController 생성

• BP_Player에 있던 액션맵핑 다 옮겨줌

Rookiss

• 정수의 원리

  얌얌코딩

• 변수, cout, debug 복습

  혼자 공부하는 C언어

• 다양한 파일 입출력 함수

정수란

• 정수는 소수점이 없는 수로, 양수, 음수, 0을 포함
• 컴퓨터는 정수를 2진수(Binary)로 변환하여 저장하고 처리
• ex) 10진수 5 → 2진수 00000101 (8비트 기준)

정수의 표현 방식

• 부호화 크기 방식
  • MSB(가장 왼쪽 비트)를 부호 비트로 사용
    • 0: 양수, 1: 음수
  • 나머지 비트는 크기 정보
  • +0과 -0이 중복 표현됨 → 비효율적, 실사용 거의 없음
• 1의 보수
  • 모든 비트를 반전시켜 음수 표현
    • 예: 5 → 00000101, 5 → 11111010
  • 여전히 +0, 0이 존재함 → 사용 잘 안 함
• 2의 보수
  • 현재 컴퓨터에서 표준으로 사용하는 음수 표현 방식
  • 방법:
    • 숫자의 이진수를 반전 (1의 보수)
    • 거기에 +1을 더함
  • 예:5 = 00000101반전 → 11111010+1 → 11111011 → 5
  • 장점:
    • +0, 0이 하나로 통합
    • 덧셈/뺄셈 연산 회로를 하나로 통합 가능 → 효율성 ↑

데이터 타입과 저장 범위

• signed: 부호 있음 → 음수 + 양수

• unsigned: 양수만 → 더 넓은 양의 값 표현 가능

• 타입 변환 시 손실 발생 가능 → 주의 필요

  • 예: int → short → 상위 비트 손실

    타입	크기(Byte)	Signed 범위	Unsigned 범위
    char	1	-128 ~ 127	0 ~ 255
    short	2	-32,768 ~ 32,767	0 ~ 65,535
    int	4	-2,147,483,648 ~ 2,147,483,647	0 ~ 4,294,967,295
    long long	8	-9경 ~ 9경 (±9,223,372조)	0 ~ 18,446경

진법과 변환

• 2진수 16진수는 4비트 단위로 나뉘어져 있어 매우 친화적

  • 2진수 4자리 = 16진수 1자리

    진법	설명	코드 표현
    2진수 (BIN)	컴퓨터 내부 기본 표현	0b1100
    10진수 (DEC)	사람이 일상 사용하는 표현	기본 숫자
    16진수 (HEX)	디버깅/주소 표현에 유용	0xF
    8진수 (OCT)	예전 시스템에서 사용	거의 사용 안 함

정수 연산

• 덧셈

| A | B | A+B | Carry |
| --- | --- | --- | --- |
| 0 | 0 | 0 | 0 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 (올림 발생) |
- 예: `5 + 3`
    - `5`: `00000101`
    - `3`: `00000011`
    - 결과: `00001000` → `8`

• 뺄셈
  • 뺄셈은 2의 보수 덧셈으로 처리
  • 예: 5 - 3 = 5 + (-3)
    • 3의 2의 보수: 11111101
    • 5 = 00000101
    • 결과 = 00000010 → 2
• 오버플로우
  • 표현 가능한 최대값을 초과
    • 예: 2147483647 + 1 → 2147483648
• 언더플로우
  • 표현 가능한 최소값보다 작음
    • 예: 2147483648 - 1 → 2147483647

메모리에 저장되는 방식

• 리틀 엔디안
  • 하위 바이트(LSB)부터 메모리에 저장
  • 예: 0x12345678 → 메모리: 78 56 34 12
  • 인텔 아키텍처에서 기본
• 빅 엔디안
  • 상위 바이트(MSB)부터 저장
  • 네트워크 통신 프로토콜에서 많이 사용

CODE

#include <iostream>
using namespace std;

// 정수의 원리
// 비트  0,1 데이터의 최소 단위
// 바이트
// 1 바이트 -> 8bit
// 컴퓨터는 전기 신호로 숫자를 만들어줌
// 최상위 비트는 -를 담당함
// 1바이트의 가장 큰 값을 01111111 : 127
// 11111111 = 1

// 복습
int hp;
// 데이터 범위
short mp;

// 진법
// 0,1,2,3,4,5,6,7,8,9 -> 10 (1과 0으로 표현) 조합하면서 무한대 숫자를 만들 수 있음\
// 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F 16 진법
// why? 16 진법
// 2진법과 궁합이 잘맞음
// 

int main()
{
    hp = 0xFF/*306189112*/;

    mp = /*(short)*/hp;    // 값을 꺼내옴 // 다른 숫자가 나옴 범위 밖의 숫자가 날아감
                    // 형변환이 필요함            
    cout << hp;

    return 0;
}

문제 1

• 1주 동안 운동 횟수를 입력 받고
• 칭찬 메시지 출력

입력 예시

5

출력 예시

멋지군요!! 칭찬합니다

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    if (a)
    {
        cout << "멋지군요!! 칭찬합니다" << endl;
    }

    return 0;
}

문제 2

• 숫자 하나를 입력 받음
• 입력 받은 숫자를 그대로 출력
• 뒤에 입력하셨군요 라는 글씨 출력

입력 예시

3

출력 예시

3 입력하셨군요

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    cout << a << " 입력하셨군요" << endl;

    return 0;
}

문제 3

• 숫자를 하나 입력 받음
• 숫자를 세번 출력
• cin과 cout만 이용

입력 예시

3

출력 예시

3 3 3

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    cout << a << " " << a << " " << a << endl;

    return 0;
}

문제 4

• 숫자 3개를 변수 a,b,c이 입력 받음
• a 3번 출력, b 3번 출력, c 3번 출력

입력 예시

3 5 9

출력 예시

333
555
999

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b, c;
    cin >> a >> b >> c;

    cout << a << "" << a << "" << a << endl;
    cout << b << "" << b << "" << b << endl;
    cout << c << "" << c << "" << c << endl;

    return 0;
}

문제 5

• 숫자 2개 입력 받음
• 앞 숫자 - 뒷 숫자의 차를 구해서 출력

입력 예시

30 10

출력 예시

두 숫자의 차는 20 입니다.

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    cout << "두 숫자의 차는 " << a - b << " 입니다." << endl;

    return 0;
}

문제 6

• 숫자 두개 입력 받고 덧셈, 곱셈, 나눗셈 출력

입력 예시

5 2

출력 예시

5 + 2 = 7
5 * 2 = 10
5 / 2 = 2

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    cout << a << "+" << b << "=" <<a + b << endl;
    cout << a << "*" << b << "=" <<a * b << endl;
    cout << a << "/" << b << "=" <<a / b << endl;

    return 0;
}

문제 7

• 변수 a,b에 숫자를 입력 받음
• 변수 a가 b보다 크면 a가 b보다 크다
• 그렇지 않으면 b가 a보다 같거나 크다를 출력

입력 예시

4 3

출력 예시

a가 b보다 크다

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    if (a > b)
    {
        cout << "a가 b보다 크다" << endl;
    }
    else
    {
        cout << "b가 a보다 같거나 크다" << endl;

    }

    return 0;
}

문제 8

• 숫자 2개를 입력
• 둘 중 큰 수를 4번 출력

입력 예시

3 5

출력 예시

5555

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b;
    cin >> a >> b;

    if (a > b)
    {
        cout << a << a << a << a << endl;
    }
    else if(b > a)
    {
        cout << b << b << b << b << endl;

    }
    else
    {

    }

    return 0;
}

문제 9

• 숫자 1개를 변수 a에 입력 받음
• 5를 입력함
• a++을 수행하면 6이 됨

입력 예시

5

출력 예시

5를 입력함
a++을 수행하면 6이 됩니다

풀이

#include <iostream>
using namespace std;

int main()
{

    int a;
    cin >> a;

    cout << a << " 를 입력함" << endl;
    a++;
    cout << "a++을 수행하면 " << a << "이 됩니다" << endl;

    return 0;
}

문제 10

• 숫자 1개를 변수 input에 입력
• 숫자가 3보다 크면 1을 더하고 출력
• 그렇지 않으면 1을 빼고 출력

입력 예시

5

출력 예시

6

풀이

#include <iostream>
using namespace std;

int main()
{

    int input;
    cin >> input;

    if (input > 3)
    {
        input++;
        cout << input << endl;
    }
    else if (input <= 3)
    {
        input--;
        cout << input << endl;
    }

    return 0;
}

문제 11

• 숫자 1개를 변수 num에 입력
• 숫자가 양수라면

###
###
###

• 숫자가 음수라면

$$$
$$$
$$$

• 숫자가 0이면 출력하지 않음

입력 예시

3

출력 예시

###
###
###

풀이

#include <iostream>
using namespace std;

int main()
{

    int num;
    cin >> num;

    if (num > 0)
    {
        cout << "###" << endl;
        cout << "###" << endl;
        cout << "###" << endl;
    }
    else if (num < 0)
    {
        cout << "$$$" << endl;
        cout << "$$$" << endl;
        cout << "$$$" << endl;
    }
    else
    {

    }

    return 0;
}

문제 12

• 숫자 3개 입력
• 세 수의 합이 세 수의 곱보다 같거나 행운의 수 출력
• 아니면 소소한 수

입력 예시

1 2 3

출력 예시

행운의 수

풀이

#include <iostream>
using namespace std;

int main()
{

    int a, b, c;
    cin >> a >> b >> c;

    if ((a + b + c) >= (a * b * c))
    {
        cout << "행운의 수" << endl;
    }
    else
    {
        cout << "소소한 수" << endl;
    }

    return 0;
}

1-1. [Quiz] 함수의 주된 사용 목적은 무엇일까요?

① 코드 실행 속도 향상

② 변수 선언 없이 사용

③ 코드 재사용성 및 관리 용이성 증대

④ 컴파일 오류 방지

1-2. [Quiz] 함수의 반환 타입이나 매개변수 목록에 'void' 키워드를 사용하는 것은 무엇을 의미할까요?

① 매개변수나 반환값이 임시 메모리에 저장된다

② 함수가 아무런 매개변수를 받지 않거나, 아무런 값을 반환하지 않는다

③ 함수가 전역 변수만 사용한다

④ 함수 실행 중 오류가 발생할 수 있다

1-3. [Quiz] 함수 내에서 선언된 지역 변수는 프로그램 실행 중 주로 메모리의 어느 영역에 할당될까요?

① 힙 (Heap)

② 코드 섹션 (Code section)

③ 스택 (Stack)

④ 데이터 섹션 (Data section)

1-4. 함수 선언(Declaration)과 정의(Definition)의 차이로 옳은 것은?

① 선언은 .cpp에, 정의는 .h에 작성한다

② 선언은 실제 구현을 포함하고, 정의는 시그니처만 가진다

③ 선언은 시그니처만(세미콜론으로 끝), 정의는 실제 구현({} 안에 코드)

④ 선언 없이 정의만 있으면 컴파일이 더 빠르다

1-5. 함수 오버로딩이 성립하는 조건으로 옳은 것은?

① 함수 이름만 같으면 된다

② 매개변수 개수나 타입이 달라야 한다

③ 반환 타입만 다르면 된다

④ 같은 .cpp 파일에 있어야 한다

1-6. C++에서 함수 호출 전에 선언이 먼저 있어야 하는 이유는?

① 실행 속도를 높이기 위해

② C++는 위에서 아래로 분석하므로, 호출 시점에 해당 함수의 존재를 알아야 함

③ 메모리 절약을 위해

④ 링커가 연결하기 위해

1-7. 전역 변수와 지역 변수의 차이로 옳은 것은?

① 전역 변수는 스택에, 지역 변수는 Data 영역에 저장된다

② 전역 변수는 Data 영역·프로그램 전체 유효, 지역 변수는 스택·함수 내 유효

③ 지역 변수는 함수 종료 후에도 값이 유지된다

④ 전역 변수를 사용하는 것이 항상 권장된다

Part 2. 객관식 (Step 2~3: 스택, 스택 프레임)

2-1. 스택 메모리의 특징으로 옳은 것은?

① FIFO(선입선출) 구조이다

② LIFO(후입선출) 구조이며, 가장 나중에 호출된 함수가 먼저 종료된다

③ 프로그램 종료 시까지 데이터가 유지된다

④ 힙보다 크기가 크다

2-2. 스택 오버플로우가 발생하는 주된 원인은?

① 전역 변수를 너무 많이 사용할 때

② 재귀 함수의 종료 조건 누락 등으로 스택 프레임이 무한히 쌓일 때

③ 지역 변수를 선언할 때

④ #include를 많이 할 때

2-3. 스택 프레임에 포함되지 않는 것은?

① 매개변수

② 반환 주소

③ 지역 변수

④ 전역 변수

2-4. 다음 코드의 출력 결과는?

void AddHp(int hp, int value) { hp += value; }
int main() {
    int hp = 100;
    AddHp(hp, 20);
    cout << hp << endl;
}

① 120

② 100

③ 20

④ 컴파일 에러

2-5. 다음 코드의 출력 결과는?

int Test(int& a) { a += 10; return a; }
int main() {
    int x = 5;
    Test(x);
    cout << x << endl;
}

① 5

② 15

③ 10

④ 컴파일 에러

2-6. 복사 전달(Call by Value)과 참조 전달(Call by Reference)의 차이로 옳은 것은?

① 복사 전달은 원본을 수정할 수 있고, 참조 전달은 불가능하다

② 복사 전달은 값만 복사되어 원본 영향 없음, 참조 전달은 원본 직접 수정 가능

③ 참조 전달은 int a 형태로 받는다

④ 복사 전달이 항상 더 빠르다

Part 3. 객관식 (Step 4: 디버깅)

3-1. [Quiz] 디버깅 시 '중단점(Breakpoint)'을 설정하는 주된 목적은 무엇일까요?

① 프로그램의 전체 실행 시간을 측정하기 위해

② 특정 코드 줄에서 프로그램 실행을 일시 중지시키기 위해

③ 코드의 문법 오류를 자동으로 수정하기 위해

④ 다른 함수를 호출하는 것을 방지하기 위해

3-2. Visual Studio에서 브레이크포인트를 설정/해제하는 단축키는?

① F5

② F9

③ F10

④ F11

3-3. F10(Step Over)과 F11(Step Into)의 차이로 옳은 것은?

① F10은 함수 내부로 진입하고, F11은 그렇지 않다

② F10은 현재 줄만 실행하고 함수 안으로 들어가지 않음, F11은 함수 내부로 진입

③ F10은 프로그램을 종료하고, F11은 재시작한다

④ 둘은 동일하다

3-4. 호출 스택(Call Stack) 창의 역할로 옳은 것은?

① 변수 값을 수정한다

② 현재까지 호출된 함수들의 순서를 추적한다

③ 컴파일 에러를 표시한다

④ 실행 속도를 측정한다

3-5. 조건부 브레이크포인트의 용도로 옳은 것은?

① 모든 줄에서 멈춘다

② 특정 조건(예: hp <= 0)이 만족될 때만 정지한다

③ 컴파일 시점에만 작동한다

④ 링킹 오류를 수정한다

3-6. 조사식(Watch) 창에서 할 수 있는 것은?

① 소스 코드를 수정한다

② 변수나 수식(hp + 200 등)을 등록해 실시간으로 값 추적

③ 브레이크포인트를 자동 설정한다

④ 실행 파일을 생성한다

Part 4. 객관식 (Step 5~6: TextRPG, 파일 분할)

4-1. [Quiz] C++에서 코드를 여러 파일로 분할할 때, 헤더 파일(.h 또는 .hpp)의 주된 역할은 무엇일까요?

① 함수의 실제 구현 내용을 담는다

② 전역 변수나 상수 값을 저장한다

③ 다른 파일에서 사용할 함수나 변수 등의 선언을 제공한다

④ 프로그램 실행에 필요한 라이브러리를 모두 포함시킨다

4-2. TextRPG의 게임 흐름 순서로 옳은 것은?

① main → EnterBattle → EnterField → SelectPlayer

② main → EnterField → EnterLobby → CreateRandomMonster

③ main → EnterLobby → SelectPlayer → EnterField → CreateRandomMonster → EnterBattle

④ main → CreateRandomMonster → EnterBattle → EnterLobby

4-3. extern int GTest;의 의미로 옳은 것은?

① GTest 메모리를 이 파일에서 정의한다

② GTest는 다른 파일에서 정의되어 있다고 선언한다

③ GTest를 반드시 사용해야 한다

④ GTest를 삭제한다

4-4. #pragma once의 역할은?

① 컴파일 속도를 높인다

② 헤더 파일이 중복으로 포함되지 않도록 한다

③ extern을 대체한다

④ 링킹을 수행한다

4-5. 컴파일·링킹 흐름 순서로 옳은 것은?

① 링킹 → 전처리 → 컴파일 → 어셈블

② 전처리 → 컴파일 → 어셈블 → 링킹

③ 컴파일 → 링킹 → 전처리 → 어셈블

④ 어셈블 → 링킹 → 컴파일 → 전처리

4-6. 'LNK: 확인할 수 없는 외부 기호' 에러의 원인은?

① #include 누락

② 선언만 있고 정의(구현)가 없음

③ #pragma once 누락

④ 매개변수 타입 불일치

1-1. CPU에 대한 설명으로 옳은 것은?

① CPU는 데이터를 영구적으로 저장할 수 있다.

② CPU는 연산 속도가 느리지만 기억력이 좋다.

③ CPU는 연산을 담당하며, 기억력이 짧아 RAM을 활용한다.

④ CPU 쿨러는 전원 공급을 담당한다.

1-2. RAM의 4가지 영역 중 '함수 호출 정보'가 저장되는 영역은?

① Code (Text)

② Data

③ Heap

④ Stack

1-3. SSD/HDD에 대한 설명으로 옳지 않은 것은?

① 전원이 꺼져도 데이터가 유지된다.

② SSD는 RAM보다 접근 속도가 빠르다.

③ 게임 설치 파일은 SSD에 저장된다.

④ 프로그램 실행 시 SSD에서 RAM으로 복사(로드)된다.

1-4. 컴파일에 대한 설명으로 옳은 것은?

① 컴파일은 프로그래밍 언어 코드를 기계어로 번역하는 과정이다.

② 컴파일러 없이도 CPU가 직접 C++ 코드를 이해할 수 있다.

③ 세미콜론을 생략해도 컴파일이 성공한다.

④ 컴파일과 빌드는 서로 다른 과정이다.

1-5. 프로그램의 핵심 요소가 아닌 것은?

① 데이터

② 로직

③ CPU

④ (없음 - ①②가 핵심)

1-6. [Quiz] 컴퓨터의 핵심 부품인 CPU와 RAM의 주된 역할 관계는 무엇인가?

① CPU는 데이터를 저장하고, RAM은 복잡한 계산을 처리한다.

② CPU는 명령을 계산/실행하고, RAM은 데이터를 일시적으로 저장한다.

③ CPU는 프로그램을 영구 저장하고, RAM은 전원을 공급한다.

④ CPU는 화면에 결과만 출력하고, RAM은 모든 입력을 관리한다.

Part 2. 객관식 (Step 4~9: 변수, 타입, main, maxHp)

2-1. 변수 사용 3단계가 아닌 것은?

① 할당 (공간 확보)

② 쓰기 (값 넣기)

③ 읽기 (값 꺼내기)

④ 삭제 (메모리 해제)

2-2. hp = 50;에서 =의 의미로 옳은 것은?

① 양쪽이 같다.

② 오른쪽 값을 왼쪽 변수에 대입한다.

③ 50을 비교한다.

④ hp와 50을 교환한다.

2-3. int 타입의 바이트 크기는?

① 1

② 2

③ 4

④ 8

2-4. 전역 변수에 대한 설명으로 옳은 것은?

① main() 안에 선언한다.

② Stack 영역에 할당된다.

③ main() 밖에 선언하며 Data 영역에 할당된다.

④ 함수 내부에서만 사용 가능하다.

2-5. maxHp를 사용해 HP를 복구할 때 올바른 코드는?

① hp = 100;

② hp = maxHp;

③ maxHp = hp;

④ hp == maxHp;

2-6. [Quiz] 프로그래밍에서 '변수(Variable)'를 사용하는 가장 중요한 이유는 무엇인가?

① 코드의 줄 수를 줄여서 프로그램을 짧게 만들려고

② 메모리 공간에 이름을 붙여 데이터를 편리하게 저장하고 사용하려고

③ 프로그램 실행 속도를 무조건 빠르게 만들려고

④ 컴퓨터의 운영체제를 설치하기 위해

Part 3. 객관식 (Step 10~11: 정수·비트, 데이터 타입)

3-1. 1바이트는 몇 비트인가?

① 4

② 8

③ 16

④ 32

3-2. 2의 보수로 -43을 구하는 방법은? (43이 주어졌을 때)

① 비트 반전

② 비트 반전 후 +1

③ -1 후 비트 반전

④ 그대로 - 부호 붙이기

3-3. 0xFF의 10진수 값은?

① 15

② 16

③ 255

④ 256

3-4. char 타입으로 'A'의 ASCII 값을 출력하려면?

① cout << ch;

② cout << (int)ch;

③ cout << int(ch);

④ ②, ③ 모두 가능

3-5. float 리터럴을 사용할 때 필요한 접미사는?

① L

② f

③ d

④ u

3-6. [Quiz] 정수형 변수(char, short, int, long long)의 크기가 1바이트, 2바이트 등으로 다른 주된 이유와 결과는 무엇인가?

① 크기가 클수록 변수의 이름을 더 길게 지을 수 있다.

② 크기에 따라 사용할 수 있는 연산자의 종류가 달라진다.

③ 크기가 클수록 더 넓은 범위의 정수를 표현하고 저장할 수 있다.

④ 크기가 작을수록 음수는 저장할 수 없게 된다.

Part 4. 객관식 (Step 12~13: 연산자, 비교·논리)

4-1. 10 % 3의 결과는?

① 0

② 1

③ 3

④ 3.333

4-2. a = hp++; 실행 후, a에 들어가는 값은?

① hp 증가 후의 값

② hp 증가 전의 값

③ 0

④ 정의되지 않음

4-3. 8 << 1의 결과는?

① 4

② 8

③ 16

④ 64

4-4. &&와 ||의 우선순위 중 더 높은 것은?

① ||

② &&

③ 같음

④ 상황에 따라 다름

4-5. 100 * (2 + 5) / 2의 결과는?

① 350

② 202

③ 3500

④ 45

4-6. [Quiz] 두 개 이상의 조건이 '모두 참(True)'이어야만 결과가 참이 되는 논리 연산자는 무엇인가?

① NOT 연산자 (!)

② AND 연산자 (&&)

③ OR 연산자 (||)

④ XOR 연산자 (^)

Part 5. 객관식 (Step 14~16: 조건문, 반복문)

5-1. switch-case에서 break를 생략하면?

① 컴파일 에러

② fall-through (다음 case까지 실행)

③ 해당 case만 실행

④ 무한 루프

5-2. for (int i = 0; i < 5; i++)에서 반복 횟수는?

① 4회

② 5회

③ 6회

④ 무한

5-3. continue의 역할은?

① 반복문을 즉시 종료

② 현재 반복 건너뛰고 다음 반복으로

③ break와 동일

④ 조건식을 건너뜀

5-4. switch-case와 if-else if를 선택할 때, switch-case가 적합한 경우는?

① 범위 비교 (예: hp <= 30)

② 정수 값 하나로 분기

③ 복잡한 논리식

④ 문자열 비교

5-5. rand() % 3의 결과 범위는?

① 0 ~ 2

② 1 ~ 3

③ 0 ~ 3

④ 0 ~ 대략 3만

5-6. [Quiz] 프로그램이 실행될 때, 특정 조건에 따라 코드의 실행 경로를 여러 갈래로 '나누어' 처리하게 만드는 문법 구조를 무엇이라고 하는가?

① 반복문 (Loop)

② 산술 연산 (Arithmetic Operation)

③ 분기문 (Branching Statement)

④ 변수 선언 (Variable Declaration)

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

복습문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

  문제 13

• 풀이

  문제 14

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이

  문제 10

• 풀이

  문제 11

• 풀이

  문제 12

• 풀이

복습 문제

문제 1

• 풀이

  문제 2

• 풀이

  문제 3

• 풀이

  문제 4

• 풀이

  문제 5

• 풀이

  문제 6

• 풀이

  문제 7

• 풀이

  문제 8

• 풀이

  문제 9

• 풀이