1.1 Database는 무엇인가

데이터베이스(Database, DB)는 여러 사람이 공유할 목적으로 체계화하여 통합, 관리하는 데이터의 집합입니다. 단순히 데이터를 저장하는 것을 넘어, 효율적으로 관리하고 필요할 때 신속하게 접근할 수 있도록 지원하는 정보 저장소입니다.

데이터베이스의 정의와 역할

핵심 기능

• 체계적 저장: 데이터를 구조화하여 중복 없이 저장
• 효율적 검색: 필요한 데이터를 빠르게 찾아 제공
• 데이터 수정: 삽입(Insert), 삭제(Delete), 갱신(Update) 지원
• 동시 접근: 여러 사용자가 동시에 데이터 이용 가능

실생활 예시

• 은행 시스템: 고객 정보, 거래 내역, 계좌 정보 관리
• 전자상거래: 상품 정보, 주문 내역, 재고 관리
• 소셜 미디어: 사용자 프로필, 게시물, 댓글 저장
• 병원 시스템: 환자 기록, 진료 내역, 처방전 관리

데이터베이스의 특징

1. 실시간 접근성 (Real-Time Accessibility)

• 사용자의 요구에 실시간으로 응답
• 즉각적인 데이터 조회 및 처리 가능

2. 계속적인 변화 (Continuous Evolution)

• 새로운 데이터의 삽입(Insert)
• 불필요한 데이터의 삭제(Delete)
• 기존 데이터의 갱신(Update)
• 항상 최신 상태의 데이터 유지

3. 동시 공용 (Concurrent Sharing)

• 다수의 사용자가 동시에 같은 데이터 이용
• 동시성 제어를 통한 데이터 일관성 유지

4. 내용에 의한 참조 (Content Reference)

• 데이터의 물리적 위치가 아닌 내용으로 검색
• 사용자 요구에 따른 데이터 내용으로 접근

데이터베이스 관리 시스템 (DBMS)

DBMS의 정의

• Database Management System의 약자
• 데이터베이스를 관리하고 운영하는 소프트웨어
• 사용자와 데이터베이스 사이의 인터페이스 역할

DBMS의 주요 기능

• 데이터 정의: 데이터 구조 정의 및 스키마 관리
• 데이터 조작: 검색, 삽입, 수정, 삭제 기능 제공
• 데이터 제어: 접근 권한 관리 및 보안 유지
• 데이터 공유: 여러 사용자의 동시 접근 지원
• 데이터 무결성: 데이터의 정확성과 일관성 보장

DBMS의 장점

• 데이터 중복 최소화
• 데이터 일관성 유지
• 데이터 보안 강화
• 데이터 표준화
• 프로그램과 데이터의 독립성

데이터베이스의 발전 역사

1세대: 계층형 데이터베이스 (Hierarchical DB)

• 1960년대 등장
• 트리(Tree) 구조로 데이터 구성
• 부모-자식 관계로 데이터 연결
• 단점: 구조 변경 어려움, 데이터 검색 비효율적
• 현재는 거의 사용되지 않음

2세대: 망형 데이터베이스 (Network DB)

• 계층형 DB의 문제점 개선
• 네트워크처럼 데이터 간 자유로운 연결
• 단점: 복잡한 구조로 프로그래밍 어려움
• 현재는 거의 사용되지 않음

3세대: 관계형 데이터베이스 (Relational DB)

• 1970년대 에드가 F. 커드(Edgar F. Codd)가 제안
• 테이블(Table) 형태로 데이터 저장
• SQL을 통한 데이터 관리
• 현재 가장 널리 사용되는 형태

4세대: NoSQL 데이터베이스

• 2000년대 이후 빅데이터 시대에 등장
• 비정형 데이터 처리에 적합
• 수평적 확장성 우수
• 다양한 데이터 모델 지원

1.2 Database 구성 요소

데이터베이스는 여러 구성 요소가 유기적으로 결합하여 데이터를 효과적으로 저장하고 관리합니다. 각 구성 요소의 역할과 관계를 이해하는 것이 중요합니다.

테이블 (Table)

정의: 데이터베이스에서 데이터를 저장하는 기본 단위

구조

• 행(Row): 개별 데이터 레코드를 나타냄 (튜플, Tuple)
• 열(Column): 데이터의 속성을 정의 (필드, Field)
• 행과 열이 교차하는 지점에 실제 데이터 값 저장

예시: 고객 정보 테이블

고객ID | 이름    | 전화번호      | 주소
-------|---------|--------------|------------------
001    | 홍길동  | 010-1234-5678| 서울시 강남구
002    | 김철수  | 010-9876-5432| 부산시 해운대구
003    | 이영희  | 010-5555-1234| 대구시 수성구

레코드 (Record)

정의: 테이블의 각 행(Row)을 의미하며, 하나의 완전한 데이터 단위

특징

• 각 열에 해당하는 데이터 값을 포함
• 테이블의 스키마에 정의된 구조를 따름
• 고유 식별자(Primary Key)로 구분 가능

예시

• 고객 테이블의 한 레코드: (001, 홍길동, 010-1234-5678, 서울시 강남구)
• 각 필드가 모여 하나의 완전한 고객 정보 구성

필드 (Field) / 속성 (Attribute)

정의: 테이블의 열(Column)을 의미하며, 데이터의 특정 속성을 나타냄

필드의 구성 요소

• 필드명: 속성의 이름 (예: 이름, 전화번호)
• 데이터 타입: 저장할 데이터의 형식 (문자열, 숫자, 날짜 등)
• 제약 조건: 데이터 입력 규칙 (NOT NULL, UNIQUE 등)

주요 데이터 타입

• 문자형: VARCHAR, CHAR, TEXT
• 숫자형: INT, BIGINT, DECIMAL, FLOAT
• 날짜/시간: DATE, TIME, DATETIME, TIMESTAMP
• 논리형: BOOLEAN

엔티티 (Entity)

정의: 독립적으로 존재하면서 고유하게 식별 가능한 실세계의 객체나 개념

엔티티의 특징

• 사람, 장소, 사물, 사건 등을 나타냄
• 여러 속성(Attribute)으로 구성
• 데이터베이스에서 테이블로 구현됨

엔티티 예시

• 고객 엔티티: 고객ID, 이름, 전화번호, 주소
• 상품 엔티티: 상품ID, 상품명, 가격, 재고량
• 주문 엔티티: 주문ID, 주문일자, 고객ID, 총액

스키마 (Schema)

정의: 데이터베이스의 구조와 제약 조건을 정의한 설계도

스키마의 종류

1. 외부 스키마 (External Schema)

• 사용자 관점의 데이터베이스 구조
• 개별 사용자나 응용 프로그램이 보는 뷰(View)
• 여러 개 존재 가능

2. 개념 스키마 (Conceptual Schema)

• 조직 전체의 데이터베이스 구조
• 모든 사용자가 공유하는 논리적 구조
• 일반적으로 '스키마'라고 하면 개념 스키마를 의미

3. 내부 스키마 (Internal Schema)

• 물리적 저장 구조
• 실제 데이터가 저장되는 방식 정의
• 하나만 존재

키 (Key)

정의: 테이블에서 레코드를 고유하게 식별하거나 관계를 정의하는 속성

주요 키의 종류

1. 기본 키 (Primary Key, PK)

• 각 레코드를 고유하게 식별하는 속성
• NULL 값 불가, 중복 불가
• 테이블당 하나만 존재
• 예: 고객ID, 주문번호

2. 외래 키 (Foreign Key, FK)

• 다른 테이블의 기본 키를 참조하는 속성
• 테이블 간 관계를 정의
• 참조 무결성 유지
• 예: 주문 테이블의 고객ID (고객 테이블 참조)

3. 후보 키 (Candidate Key)

• 기본 키가 될 수 있는 속성들
• 유일성과 최소성을 만족

4. 대체 키 (Alternate Key)

• 후보 키 중 기본 키로 선택되지 않은 키

5. 복합 키 (Composite Key)

• 두 개 이상의 속성을 조합한 키

관계 (Relationship)

정의: 엔티티(테이블) 간의 연관성을 나타내는 개념

관계의 유형

1. 일대일 (1:1) 관계

• 한 엔티티의 레코드가 다른 엔티티의 정확히 하나의 레코드와 연결
• 예: 사원 - 사원증 (한 사원은 하나의 사원증만 보유)

2. 일대다 (1:N) 관계

• 한 엔티티의 레코드가 다른 엔티티의 여러 레코드와 연결
• 가장 흔한 관계 유형
• 예: 고객 - 주문 (한 고객이 여러 주문 가능)

3. 다대다 (N:M) 관계

• 양쪽 엔티티의 레코드가 서로 여러 개와 연결
• 중간 테이블(연결 테이블)로 구현
• 예: 학생 - 과목 (한 학생이 여러 과목 수강, 한 과목을 여러 학생이 수강)

인덱스 (Index)

정의: 데이터 검색 속도를 향상시키기 위한 데이터 구조

인덱스의 원리

• 책의 색인과 유사한 개념
• 특정 열의 값과 해당 레코드의 위치 정보 저장
• B-Tree, Hash 등의 자료구조 사용

인덱스의 장점

• 검색 속도 대폭 향상 (특히 대용량 데이터)
• WHERE, ORDER BY, JOIN 연산 최적화
• 데이터 정렬 비용 감소

인덱스의 단점

• 추가 저장 공간 필요
• INSERT, UPDATE, DELETE 시 성능 저하
• 인덱스 유지 관리 비용

인덱스 사용 전략

• 자주 검색되는 열에 생성
• WHERE 절에 자주 사용되는 열
• JOIN 조건으로 사용되는 열
• 카디널리티(고유값 비율)가 높은 열

1.3 DB 생성 원칙

효과적인 데이터베이스를 설계하기 위해서는 체계적인 원칙과 방법론을 따라야 합니다. 데이터 무결성, 정규화, 성능 최적화 등을 고려한 설계가 필요합니다.

데이터 무결성 (Data Integrity)

정의: 데이터의 정확성, 일관성, 유효성이 유지되는 것

무결성의 종류

1. 개체 무결성 (Entity Integrity)

• 기본 키는 NULL 값을 가질 수 없음
• 기본 키는 중복될 수 없음
• 각 레코드를 고유하게 식별 보장

2. 참조 무결성 (Referential Integrity)

• 외래 키 값은 참조 테이블의 기본 키 값이어야 함
• 또는 NULL 값 허용 (선택적 관계인 경우)
• 존재하지 않는 데이터 참조 방지

3. 도메인 무결성 (Domain Integrity)

• 각 속성 값은 정의된 도메인(범위) 내에 있어야 함
• 데이터 타입, 길이, 형식 제약 준수
• CHECK 제약 조건으로 구현

4. 사용자 정의 무결성 (User-Defined Integrity)

• 비즈니스 규칙에 따른 제약 조건
• 예: 주문 수량은 0보다 커야 함

정규화 (Normalization)

정의: 데이터 중복을 최소화하고 무결성을 향상시키기 위해 테이블을 분해하는 과정

정규화의 목적

• 데이터 중복 제거
• 삽입/수정/삭제 이상(Anomaly) 방지
• 데이터 일관성 유지
• 저장 공간 효율화

제1정규형 (1NF)

• 모든 속성 값은 원자값(Atomic Value)이어야 함
• 반복 그룹 제거
• 각 열은 하나의 값만 포함

예시

비정규형:
학생ID | 이름   | 수강과목
001    | 홍길동 | 수학, 영어, 과학

1NF:
학생ID | 이름   | 수강과목
001    | 홍길동 | 수학
001    | 홍길동 | 영어
001    | 홍길동 | 과학

제2정규형 (2NF)

• 1NF를 만족
• 부분 함수 종속 제거
• 기본 키가 아닌 모든 속성이 기본 키에 완전 함수 종속

제3정규형 (3NF)

• 2NF를 만족
• 이행적 함수 종속 제거
• 기본 키가 아닌 속성 간의 종속 관계 제거

역정규화 (Denormalization)

정의: 성능 향상을 위해 의도적으로 중복을 허용하는 과정

역정규화가 필요한 경우

• 조인 연산이 너무 많아 성능 저하
• 복잡한 쿼리로 인한 응답 시간 증가
• 읽기 작업이 압도적으로 많은 경우

역정규화 기법

• 테이블 통합: 자주 조인되는 테이블 병합
• 중복 열 추가: 계산 결과나 집계 값 저장
• 파생 열 추가: 자주 계산되는 값 미리 저장
• 요약 테이블: 집계 데이터를 별도 테이블로 관리

주의사항

• 데이터 일관성 유지 메커니즘 필요
• 업데이트 비용 증가 고려
• 저장 공간 증가 감수

명명 규칙 (Naming Convention)

테이블 명명 규칙

• 명확하고 의미 있는 이름 사용
• 복수형 사용 권장 (예: users, orders)
• 소문자와 언더스코어 사용 (snake_case)
• 예약어 사용 금지

열 명명 규칙

• 설명적이고 간결한 이름
• 테이블명 접두사 불필요 (테이블 컨텍스트에서 명확)
• 일관된 명명 패턴 유지
• 예: user_id, created_at, email_address

제약 조건 명명

• PK: pk_테이블명
• FK: fk_테이블명_참조테이블명
• INDEX: idx_테이블명_열명
• UNIQUE: uq_테이블명_열명

데이터베이스 설계 프로세스

1단계: 요구사항 분석

• 비즈니스 요구사항 파악
• 데이터 항목 식별
• 사용자 요구사항 수집

2단계: 개념적 설계

• ER(Entity-Relationship) 다이어그램 작성
• 엔티티와 관계 정의
• 속성 식별

3단계: 논리적 설계

• ER 다이어그램을 관계형 스키마로 변환
• 정규화 수행
• 키 정의 (기본 키, 외래 키)

4단계: 물리적 설계

• DBMS 선택
• 인덱스 설계
• 파티셔닝 전략
• 저장 공간 할당

5단계: 구현 및 테스트

• DDL(Data Definition Language)로 스키마 생성
• 샘플 데이터로 테스트
• 성능 튜닝

성능 최적화 원칙

쿼리 최적화

• SELECT 시 필요한 열만 조회 (SELECT * 지양)
• WHERE 절에 인덱스 활용
• 서브쿼리보다 JOIN 사용 권장
• LIMIT 절로 결과 제한

인덱스 전략

• 자주 검색되는 열에 인덱스 생성
• 복합 인덱스 활용 (여러 열 조합)
• 인덱스 개수 적정 유지 (과도한 인덱스는 역효과)

테이블 파티셔닝

• 대용량 테이블을 작은 단위로 분할
• 범위, 리스트, 해시 파티셔닝
• 쿼리 성능 향상 및 관리 용이성

캐싱 전략

• 자주 조회되는 데이터 캐싱
• Redis, Memcached 등 활용
• 데이터베이스 부하 감소

1.4 RDBMS와 NoSQL 비교

데이터베이스는 크게 관계형 데이터베이스(RDBMS)와 NoSQL 데이터베이스로 구분됩니다. 각각의 철학, 구조, 강점이 완전히 다르며, 프로젝트의 특성에 따라 적절한 선택이 필요합니다.

RDBMS (관계형 데이터베이스)

정의: 테이블 간의 관계를 기반으로 데이터를 구조화하여 관리하는 데이터베이스 시스템

핵심 철학

• 정확성과 일관성 중심: 한 글자, 한 숫자라도 틀리면 안 되는 데이터 관리
• ACID 트랜잭션: 데이터 무결성을 최우선으로 보장
• 구조화된 데이터: 명확한 스키마로 데이터 구조 정의

데이터 모델

• 테이블(Table) 형식의 관계형 데이터 모델
• 행(Row)과 열(Column)로 구성
• 테이블 간 관계(Relationship)로 연결
• 정형화된 데이터 저장

스키마

• 정적 스키마 (Static Schema)
• 데이터 구조를 미리 정의 필수
• 데이터 타입과 제약 조건 명시
• 스키마 변경이 어렵고 신중해야 함

RDBMS의 장점

1. 데이터 무결성 보장

• ACID 속성으로 트랜잭션 안정성 확보
• 참조 무결성으로 데이터 일관성 유지
• 제약 조건으로 잘못된 데이터 입력 방지

2. 표준화된 쿼리 언어

• SQL이라는 강력하고 표준화된 언어 제공
• 복잡한 쿼리와 조인 연산 지원
• 학습 곡선이 완만하고 자료 풍부

3. 데이터 중복 최소화

• 정규화를 통한 중복 제거
• 저장 공간 효율적 사용
• 데이터 일관성 유지 용이

4. 성숙한 생태계

• 수십 년간 검증된 기술
• 풍부한 도구와 라이브러리
• 전문 인력 확보 용이

RDBMS의 단점

1. 확장성 제한

• 수직 확장(Scale-up)에 의존
• 서버 성능 향상에 한계 존재
• 수평 확장(Scale-out) 어려움

2. 스키마 유연성 부족

• 스키마 변경이 복잡하고 비용 높음
• 애자일 개발 환경에 부적합할 수 있음
• 비정형 데이터 처리 어려움

3. 성능 이슈

• 대용량 데이터 처리 시 성능 저하
• 복잡한 조인 연산의 비용
• 특수 하드웨어 필요 가능성

4. 고정된 구조

• 다양한 형태의 데이터 저장 제약
• 반정형/비정형 데이터 처리 한계

주요 RDBMS 제품

MySQL

• 가장 널리 사용되는 오픈소스 RDBMS
• LAMP 스택의 핵심 구성 요소
• 웹 애플리케이션에 최적화
• 커뮤니티 에디션 무료 제공

PostgreSQL

• 고급 기능을 갖춘 오픈소스 RDBMS
• ACID 준수 및 확장성 우수
• 복잡한 쿼리와 대용량 데이터 처리
• JSON 지원으로 NoSQL 기능 일부 제공

Oracle Database

• 대기업용 상용 데이터베이스
• 최고 수준의 성능과 안정성
• 엔터프라이즈 기능 풍부
• 높은 라이선스 비용

Microsoft SQL Server

• 마이크로소프트의 상용 RDBMS
• Windows 환경과 긴밀한 통합
• .NET 개발과 호환성 우수
• Azure 클라우드 지원

MariaDB

• MySQL의 포크 프로젝트
• MySQL과 높은 호환성
• 오픈소스 정책 유지
• 성능 개선 및 추가 기능

SQLite

• 경량 임베디드 데이터베이스
• 서버 없이 파일 기반 동작
• 모바일 앱, 소규모 프로젝트에 적합

RDBMS 적합한 사용 사례

금융 시스템

• 은행 거래, 결제 시스템
• 정확성과 일관성이 최우선
• ACID 트랜잭션 필수
• 감사 추적(Audit Trail) 필요

전자상거래

• 주문 관리, 재고 관리
• 복잡한 비즈니스 로직
• 데이터 무결성 중요
• 트랜잭션 처리 빈번

ERP/CRM 시스템

• 기업 자원 관리
• 고객 관계 관리
• 정형화된 데이터 구조
• 복잡한 관계와 제약 조건

회계 시스템

• 재무 데이터 관리
• 정확한 계산과 기록
• 법적 요구사항 준수

NoSQL (비관계형 데이터베이스)

정의: "Not Only SQL"의 약자로, 관계형 모델을 따르지 않는 다양한 형태의 데이터베이스

핵심 철학

• 유연성과 확장성 중심: 빠르게 변화하는 데이터 구조 대응
• 수평적 확장: 서버 추가로 성능 향상
• 비정형 데이터 처리: 다양한 형태의 데이터 저장

데이터 모델

• 다양한 데이터 모델 지원
• 키-값(Key-Value), 문서(Document), 열 지향(Column-family), 그래프(Graph)
• 비정형 또는 반정형 데이터 저장
• 스키마리스(Schema-less) 또는 동적 스키마

스키마

• 동적 스키마 (Dynamic Schema)
• 데이터 구조를 미리 정의할 필요 없음
• 필드 추가/삭제가 자유로움
• 애자일 개발에 적합

NoSQL의 장점

1. 수평적 확장성

• 서버 추가로 성능 향상 (Scale-out)
• 클러스터링을 통한 분산 처리
• 대용량 데이터 처리에 유리
• 비용 효율적인 확장

2. 유연한 스키마

• 스키마 변경이 자유로움
• 다양한 형태의 데이터 저장 가능
• 빠른 개발 및 반복 가능
• 비정형 데이터 처리 우수

3. 높은 성능

• 특정 작업에 최적화된 구조
• 빠른 읽기/쓰기 속도
• 상용 하드웨어 사용 가능
• 캐싱 메커니즘 내장

4. 대용량 데이터 처리

• 빅데이터 환경에 적합
• 실시간 분석 지원
• 로그 데이터, 센서 데이터 처리

NoSQL의 단점

1. 데이터 일관성 약화

• ACID 대신 BASE 모델 (Basically Available, Soft state, Eventually consistent)
• 최종 일관성(Eventually Consistent) 보장
• 즉각적인 일관성 보장 어려움

2. 표준화 부족

• 각 NoSQL 데이터베이스마다 고유한 쿼리 언어
• SQL처럼 표준화된 언어 없음
• 학습 곡선이 가파를 수 있음

3. 복잡한 쿼리 제한

• 조인 연산 미지원 또는 제한적
• 복잡한 트랜잭션 처리 어려움
• 애플리케이션 레벨에서 처리 필요

4. 성숙도

• RDBMS에 비해 역사가 짧음
• 도구와 생태계가 상대적으로 부족
• 전문 인력 확보 어려울 수 있음

NoSQL 데이터베이스 유형

1. 문서 데이터베이스 (Document Database)

• JSON, BSON, XML 형식으로 데이터 저장
• 계층적 데이터 구조 지원
• 예: MongoDB, CouchDB, Elasticsearch
• 사용 사례: 콘텐츠 관리, 사용자 프로필

2. 키-값 데이터베이스 (Key-Value Store)

• 단순한 키-값 쌍으로 데이터 저장
• 매우 빠른 읽기/쓰기 성능
• 예: Redis, Memcached, DynamoDB
• 사용 사례: 캐싱, 세션 관리, 실시간 분석

3. 열 지향 데이터베이스 (Column-family Store)

• 열 단위로 데이터 저장 및 압축
• 대용량 데이터 분석에 최적화
• 예: Cassandra, HBase, Google Bigtable
• 사용 사례: 시계열 데이터, 로그 분석

4. 그래프 데이터베이스 (Graph Database)

• 노드와 엣지로 관계 표현
• 복잡한 관계 쿼리에 최적화
• 예: Neo4j, ArangoDB, Amazon Neptune
• 사용 사례: 소셜 네트워크, 추천 시스템, 지식 그래프

주요 NoSQL 제품

MongoDB

• 가장 인기 있는 문서 데이터베이스
• JSON 형식의 BSON 문서 저장
• 풍부한 쿼리 기능과 인덱싱
• 수평적 확장 지원 (샤딩)

Redis

• 인메모리 키-값 저장소
• 초고속 읽기/쓰기 성능
• 다양한 데이터 구조 지원 (문자열, 리스트, 셋, 해시)
• 캐싱, 세션 관리에 널리 사용

Cassandra

• 분산 열 지향 데이터베이스
• 높은 가용성과 확장성
• 쓰기 성능 우수
• 대용량 데이터 처리

Elasticsearch

• 검색 및 분석 엔진
• 전문 검색(Full-text Search) 기능
• 실시간 데이터 분석
• 로그 및 이벤트 데이터 처리

Neo4j

• 그래프 데이터베이스
• 관계 중심 데이터 모델
• Cypher 쿼리 언어
• 소셜 네트워크, 추천 시스템

NoSQL 적합한 사용 사례

소셜 미디어 플랫폼

• 사용자 피드, 게시물, 댓글
• 비정형 데이터 (이미지, 동영상 메타데이터)
• 대량의 읽기/쓰기 작업
• 실시간 업데이트

IoT 및 센서 데이터

• 시계열 데이터 수집
• 초당 수만 건의 데이터 발생
• 실시간 분석 필요
• 스키마 변경 빈번

콘텐츠 관리 시스템

• 다양한 형태의 콘텐츠
• 유연한 데이터 구조
• 빠른 검색 기능
• 확장 가능한 아키텍처

실시간 분석

• 로그 데이터 분석
• 사용자 행동 추적
• 대시보드 및 리포팅
• 빅데이터 처리

캐싱 레이어

• 데이터베이스 부하 감소
• 응답 시간 단축
• 세션 관리
• 임시 데이터 저장

RDBMS vs NoSQL 비교표

선택 가이드: RDBMS vs NoSQL

RDBMS를 선택해야 하는 경우

• 데이터 무결성과 일관성이 최우선
• 복잡한 트랜잭션 처리 필요
• 정형화된 데이터 구조
• 복잡한 조인과 쿼리 빈번
• ACID 속성 필수
• 예: 은행 시스템, 회계 시스템, ERP

NoSQL을 선택해야 하는 경우

• 대용량 데이터 처리
• 빠른 읽기/쓰기 성능 필요
• 스키마가 자주 변경됨
• 수평적 확장 필요
• 비정형/반정형 데이터
• 예: 소셜 미디어, IoT, 실시간 분석

하이브리드 접근

• 많은 현대 애플리케이션은 두 가지를 함께 사용
• RDBMS: 핵심 트랜잭션 데이터
• NoSQL: 캐싱, 세션, 로그 데이터
• 각 데이터베이스의 강점 활용
• Polyglot Persistence 패턴

2.5 SQL 언어

SQL(Structured Query Language)은 관계형 데이터베이스에서 데이터를 관리하기 위한 표준 프로그래밍 언어입니다. 1970년대부터 사용되어 온 SQL은 데이터 정의, 조작, 제어를 위한 강력하고 표준화된 도구입니다.

SQL의 개요

정의

• "Structured Query Language"의 약자
• "에스큐엘" 또는 "시퀄"로 발음
• 관계형 데이터베이스의 표준 언어
• ANSI/ISO 표준으로 제정

SQL의 역할

• 데이터베이스 레코드 삽입, 검색, 업데이트, 삭제
• 데이터베이스 스키마 생성 및 수정
• 접근 권한 설정 및 관리
• 데이터베이스 최적화 및 유지 관리

SQL의 특징

• 선언적 언어 (무엇을 할지 명시, 어떻게 할지는 DBMS가 결정)
• 집합 기반 언어 (한 번에 여러 행 처리)
• 대소문자 구분 없음 (관례적으로 키워드는 대문자)
• 세미콜론(;)으로 문장 종료

SQL의 분류

1. DDL (Data Definition Language) - 데이터 정의어

• 데이터베이스 구조를 정의하고 수정
• 주요 명령어: CREATE, ALTER, DROP, TRUNCATE
• 스키마, 테이블, 인덱스 등 생성/수정/삭제

2. DML (Data Manipulation Language) - 데이터 조작어

• 데이터를 조회하고 변경
• 주요 명령어: SELECT, INSERT, UPDATE, DELETE
• 가장 빈번하게 사용되는 SQL 명령어

3. DCL (Data Control Language) - 데이터 제어어

• 데이터 접근 권한 관리
• 주요 명령어: GRANT, REVOKE
• 사용자 권한 부여 및 회수

4. TCL (Transaction Control Language) - 트랜잭션 제어어

• 트랜잭션 관리
• 주요 명령어: COMMIT, ROLLBACK, SAVEPOINT
• 데이터 변경 사항 확정 또는 취소

DDL (Data Definition Language)

CREATE - 데이터베이스 객체 생성

-- 데이터베이스 생성
CREATE DATABASE company;

-- 테이블 생성
CREATE TABLE employees (
    employee_id INT PRIMARY KEY AUTO_INCREMENT,
    first_name VARCHAR(50) NOT NULL,
    last_name VARCHAR(50) NOT NULL,
    email VARCHAR(100) UNIQUE,
    hire_date DATE,
    salary DECIMAL(10, 2),
    department_id INT,
    FOREIGN KEY (department_id) REFERENCES departments(department_id)
);

-- 인덱스 생성
CREATE INDEX idx_last_name ON employees(last_name);

ALTER - 데이터베이스 객체 수정

-- 열 추가
ALTER TABLE employees ADD COLUMN phone VARCHAR(20);

-- 열 수정
ALTER TABLE employees MODIFY COLUMN salary DECIMAL(12, 2);

-- 열 삭제
ALTER TABLE employees DROP COLUMN phone;

-- 제약 조건 추가
ALTER TABLE employees ADD CONSTRAINT chk_salary CHECK (salary > 0);

DROP - 데이터베이스 객체 삭제

-- 테이블 삭제 (구조와 데이터 모두 삭제)
DROP TABLE employees;

-- 데이터베이스 삭제
DROP DATABASE company;

-- 인덱스 삭제
DROP INDEX idx_last_name ON employees;

TRUNCATE - 테이블 데이터 삭제

-- 테이블의 모든 데이터 삭제 (구조는 유지)
TRUNCATE TABLE employees;
-- DELETE보다 빠르지만 롤백 불가

DML (Data Manipulation Language)

SELECT - 데이터 조회

-- 기본 조회
SELECT * FROM employees;

-- 특정 열 조회
SELECT first_name, last_name, salary FROM employees;

-- 조건부 조회 (WHERE)
SELECT * FROM employees WHERE salary > 50000;

-- 정렬 (ORDER BY)
SELECT * FROM employees ORDER BY salary DESC;

-- 제한 (LIMIT)
SELECT * FROM employees LIMIT 10;

-- 집계 함수
SELECT COUNT(*) FROM employees;
SELECT AVG(salary) FROM employees;
SELECT MAX(salary), MIN(salary) FROM employees;

-- 그룹화 (GROUP BY)
SELECT department_id, AVG(salary) 
FROM employees 
GROUP BY department_id;

-- HAVING (그룹 조건)
SELECT department_id, AVG(salary) 
FROM employees 
GROUP BY department_id 
HAVING AVG(salary) > 60000;

INSERT - 데이터 삽입

-- 단일 행 삽입
INSERT INTO employees (first_name, last_name, email, hire_date, salary, department_id)
VALUES ('John', 'Doe', 'john.doe@company.com', '2024-01-15', 65000.00, 1);

-- 여러 행 삽입
INSERT INTO employees (first_name, last_name, email, hire_date, salary, department_id)
VALUES 
    ('Jane', 'Smith', 'jane.smith@company.com', '2024-01-20', 70000.00, 2),
    ('Bob', 'Johnson', 'bob.johnson@company.com', '2024-02-01', 55000.00, 1);

-- 다른 테이블에서 데이터 복사
INSERT INTO employees_backup
SELECT * FROM employees WHERE department_id = 1;

UPDATE - 데이터 수정

-- 특정 행 수정
UPDATE employees 
SET salary = 75000.00 
WHERE employee_id = 1;

-- 여러 열 수정
UPDATE employees 
SET salary = salary * 1.1, 
    email = 'new.email@company.com' 
WHERE department_id = 2;

-- 조건부 수정
UPDATE employees 
SET salary = salary * 1.05 
WHERE hire_date < '2023-01-01';

DELETE - 데이터 삭제

-- 특정 행 삭제
DELETE FROM employees WHERE employee_id = 1;

-- 조건부 삭제
DELETE FROM employees WHERE department_id = 3;

-- 모든 행 삭제 (테이블 구조는 유지)
DELETE FROM employees;

JOIN - 테이블 결합

INNER JOIN - 교집합

-- 두 테이블의 일치하는 행만 반환
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
INNER JOIN departments d ON e.department_id = d.department_id;

LEFT JOIN - 왼쪽 테이블 기준

-- 왼쪽 테이블의 모든 행 + 오른쪽 테이블의 일치하는 행
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
LEFT JOIN departments d ON e.department_id = d.department_id;

RIGHT JOIN - 오른쪽 테이블 기준

-- 오른쪽 테이블의 모든 행 + 왼쪽 테이블의 일치하는 행
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
RIGHT JOIN departments d ON e.department_id = d.department_id;

FULL OUTER JOIN - 합집합

-- 양쪽 테이블의 모든 행 (MySQL은 미지원, UNION으로 구현)
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
LEFT JOIN departments d ON e.department_id = d.department_id
UNION
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
RIGHT JOIN departments d ON e.department_id = d.department_id;

CROSS JOIN - 카티션 곱

-- 모든 가능한 조합
SELECT e.first_name, d.department_name
FROM employees e
CROSS JOIN departments d;

SELF JOIN - 자기 자신과 조인

-- 같은 테이블을 두 번 참조
SELECT e1.first_name AS employee, e2.first_name AS manager
FROM employees e1
INNER JOIN employees e2 ON e1.manager_id = e2.employee_id;

서브쿼리 (Subquery)

단일 행 서브쿼리

-- 평균 급여보다 높은 직원 조회
SELECT first_name, last_name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);

다중 행 서브쿼리

-- IN 연산자 사용
SELECT first_name, last_name
FROM employees
WHERE department_id IN (
    SELECT department_id 
    FROM departments 
    WHERE location = 'Seoul'
);

-- ANY/ALL 연산자
SELECT first_name, salary
FROM employees
WHERE salary > ANY (
    SELECT salary 
    FROM employees 
    WHERE department_id = 1
);

상관 서브쿼리

-- 각 부서의 평균보다 높은 급여를 받는 직원
SELECT e1.first_name, e1.salary, e1.department_id
FROM employees e1
WHERE salary > (
    SELECT AVG(salary)
    FROM employees e2
    WHERE e2.department_id = e1.department_id
);

FROM 절 서브쿼리 (인라인 뷰)

SELECT dept_avg.department_id, dept_avg.avg_salary
FROM (
    SELECT department_id, AVG(salary) as avg_salary
    FROM employees
    GROUP BY department_id
) AS dept_avg
WHERE dept_avg.avg_salary > 60000;

트랜잭션 (Transaction)

트랜잭션의 정의

• 하나의 논리적 작업 단위를 구성하는 일련의 연산들
• 모두 성공하거나 모두 실패해야 함 (All or Nothing)

ACID 속성

• Atomicity (원자성): 트랜잭션의 모든 연산이 완전히 수행되거나 전혀 수행되지 않음
• Consistency (일관성): 트랜잭션 실행 전후 데이터베이스가 일관된 상태 유지
• Isolation (격리성): 동시 실행 트랜잭션들이 서로 영향을 주지 않음
• Durability (지속성): 완료된 트랜잭션의 결과는 영구적으로 반영

트랜잭션 제어 명령어

-- 트랜잭션 시작 (암묵적으로 시작됨)
START TRANSACTION;
-- 또는
BEGIN;

-- 작업 수행
UPDATE accounts SET balance = balance - 1000 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 1000 WHERE account_id = 2;

-- 트랜잭션 확정 (변경사항 영구 저장)
COMMIT;

-- 트랜잭션 취소 (변경사항 되돌림)
ROLLBACK;

-- 저장점 설정
SAVEPOINT savepoint1;
-- 특정 저장점으로 롤백
ROLLBACK TO savepoint1;

트랜잭션 예시

START TRANSACTION;

-- 계좌 이체 작업
UPDATE accounts 
SET balance = balance - 100000 
WHERE account_id = 'A001';

UPDATE accounts 
SET balance = balance + 100000 
WHERE account_id = 'B001';

-- 잔액 확인
SELECT balance FROM accounts WHERE account_id = 'A001';

-- 문제 없으면 확정
COMMIT;
-- 문제 있으면 취소
-- ROLLBACK;

주요 RDBMS별 SQL 특징

MySQL

• 가장 널리 사용되는 오픈소스 RDBMS
• AUTO_INCREMENT로 자동 증가 컬럼 생성
• LIMIT 절로 결과 제한
• 다양한 스토리지 엔진 (InnoDB, MyISAM)

-- MySQL 특화 문법
SELECT * FROM employees LIMIT 10 OFFSET 20;
CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100)
) ENGINE=InnoDB;

PostgreSQL

• 고급 기능을 갖춘 오픈소스 RDBMS
• SERIAL 타입으로 자동 증가
• 강력한 JSON 지원
• 윈도우 함수, CTE 등 고급 기능

-- PostgreSQL 특화 문법
SELECT * FROM employees LIMIT 10 OFFSET 20;
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    metadata JSONB
);

-- CTE (Common Table Expression)
WITH dept_avg AS (
    SELECT department_id, AVG(salary) as avg_sal
    FROM employees
    GROUP BY department_id
)
SELECT * FROM dept_avg WHERE avg_sal > 60000;

Oracle Database

• 엔터프라이즈급 상용 RDBMS
• SEQUENCE로 자동 증가 구현
• ROWNUM으로 결과 제한
• PL/SQL 프로시저 언어

-- Oracle 특화 문법
SELECT * FROM employees WHERE ROWNUM <= 10;

CREATE SEQUENCE emp_seq START WITH 1;
INSERT INTO employees (id, name) 
VALUES (emp_seq.NEXTVAL, 'John');

Microsoft SQL Server

• 마이크로소프트의 상용 RDBMS
• IDENTITY로 자동 증가
• TOP 절로 결과 제한
• T-SQL 프로시저 언어

-- SQL Server 특화 문법
SELECT TOP 10 * FROM employees;

CREATE TABLE users (
    id INT IDENTITY(1,1) PRIMARY KEY,
    name VARCHAR(100)
);

MariaDB

• MySQL의 포크 프로젝트
• MySQL과 높은 호환성
• 추가 스토리지 엔진 (ColumnStore)
• 향상된 성능과 기능

-- MariaDB는 MySQL과 거의 동일한 문법
SELECT * FROM employees LIMIT 10;

형상 관리(Configuration Management) 또는 버전 관리(Version Control)는 소프트웨어 개발 과정에서 소스 코드와 관련 파일들의 변경 사항을 체계적으로 추적하고 관리하는 시스템입니다.

형상 관리 시스템은 다음과 같은 핵심 기능을 제공합니다:

• 변경 이력 추적: 누가, 언제, 무엇을, 왜 변경했는지 기록
• 버전 관리: 코드의 특정 시점 상태를 저장하고 복원
• 협업 지원: 여러 개발자가 동시에 작업 가능
• 충돌 해결: 동일 파일의 동시 수정 시 병합 지원

형상 관리의 필요성

개발 과정의 안정성 확보

• 실수로 코드를 삭제하거나 잘못 수정해도 이전 버전으로 복구 가능
• 새로운 기능 개발 중 문제 발생 시 안정적인 버전으로 롤백

효율적인 협업 환경 구축

• 여러 개발자가 동시에 다른 기능을 개발 가능
• 각자의 작업을 독립적으로 진행하고 나중에 통합
• 코드 리뷰와 품질 관리 프로세스 지원

형상 관리 시스템의 유형

중앙 집중식 버전 관리 (CVCS)

• 중앙 서버에 모든 버전 정보 저장
• 예: SVN (Subversion), CVS
• 단점: 서버 장애 시 작업 불가, 네트워크 필요

분산 버전 관리 (DVCS)

• 각 개발자가 전체 저장소의 복사본 보유
• 예: Git, Mercurial
• 장점: 오프라인 작업 가능, 빠른 속도, 유연한 워크플로우

1.2 GitHub란 무엇이고 왜 사용하는가

GitHub는 Git을 기반으로 하는 클라우드 기반 소스 코드 호스팅 및 협업 플랫폼입니다. Microsoft가 소유한 이 웹 서비스는 전 세계 7,300만 명 이상의 개발자가 사용하는 세계 최대의 소프트웨어 개발 플랫폼입니다.

Git과 GitHub의 관계

Git (도구)

• 로컬 컴퓨터에서 실행되는 버전 관리 시스템
• 무료 오픈소스 소프트웨어
• 명령줄(CLI) 또는 GUI 도구로 사용
• 소스 코드 변경 사항을 추적하고 관리

GitHub (서비스)

• Git 저장소를 클라우드에 호스팅하는 웹 서비스
• Git의 기능에 협업 도구 추가 제공
• 웹 인터페이스를 통한 편리한 관리
• 소셜 코딩 기능 (팔로우, 스타, 포크 등)

GitHub를 사용하는 이유

1. 코드 백업 및 접근성

• 클라우드에 코드 저장으로 데이터 손실 방지
• 어디서나 인터넷만 있으면 프로젝트 접근 가능
• 집 데스크톱에서 작업하다 노트북으로 이어서 작업 가능

2. 협업 기능

• Pull Request를 통한 코드 리뷰
• Issue 트래킹으로 버그 및 기능 요청 관리
• 프로젝트 관리 도구 (Projects, Milestones)
• 팀원 간 코드 공유 및 토론

3. 오픈소스 생태계

• 전 세계 개발자들과 협업
• 오픈소스 프로젝트 기여 및 학습
• 포트폴리오 구축 및 경력 관리

GitHub의 주요 활용 사례

개인 프로젝트 관리

• 개인 학습 및 실험 프로젝트 저장
• 포트폴리오 웹사이트 호스팅 (GitHub Pages)
• 개발 이력 및 성장 과정 기록

팀 협업

• 기업 프로젝트의 소스 코드 관리
• 코드 리뷰 프로세스 구축
• CI/CD 파이프라인 통합 (GitHub Actions)

오픈소스 기여

• 공개 프로젝트 참여 및 기여
• 커뮤니티와 지식 공유
• 기술 문서 및 튜토리얼 작성

1.3 GitHub의 주요 개념

GitHub를 효과적으로 사용하기 위해서는 핵심 개념들을 이해해야 합니다. 이러한 개념들은 Git의 기본 원리와 GitHub의 협업 기능을 포함합니다.

Repository (저장소)

정의: 프로젝트의 모든 파일과 각 파일의 수정 이력을 저장하는 공간

로컬 저장소 (Local Repository)

• 개발자의 컴퓨터에 있는 저장소
• 오프라인에서도 작업 가능
• git init 명령으로 생성

원격 저장소 (Remote Repository)

• GitHub 서버에 있는 저장소
• 팀원들과 공유하는 중앙 저장소
• 웹 인터페이스 또는 git clone으로 접근

Commit (커밋)

정의: 파일의 변경 사항을 저장소에 기록하는 행위

커밋의 구성 요소

• 변경된 파일들의 스냅샷
• 커밋 메시지 (변경 내용 설명)
• 작성자 정보 (이름, 이메일)
• 타임스탬프
• 고유 식별자 (SHA-1 해시)

좋은 커밋 메시지 작성법

• 첫 줄: 50자 이내의 간결한 요약
• 본문: 변경 이유와 내용 상세 설명
• 명령형 현재 시제 사용 ("Add feature" not "Added feature")

Branch (브랜치)

정의: 독립적인 작업 공간을 만들어 메인 코드에 영향 없이 개발할 수 있는 기능

주요 브랜치 유형

• main/master: 배포 가능한 안정적인 코드
• develop: 개발 중인 최신 코드
• feature: 새로운 기능 개발용
• hotfix: 긴급 버그 수정용

브랜치 전략의 장점

• 여러 기능을 동시에 개발 가능
• 실험적인 코드 작성 시 안전성 확보
• 코드 리뷰 및 테스트 후 병합 가능

Merge (병합)

정의: 서로 다른 브랜치의 변경 사항을 하나로 합치는 작업

병합 방식

• Fast-forward merge: 단순히 포인터만 이동
• 3-way merge: 공통 조상을 기준으로 병합
• Squash merge: 여러 커밋을 하나로 압축

충돌 (Conflict) 해결

• 같은 파일의 같은 부분을 다르게 수정했을 때 발생
• 수동으로 충돌 부분을 확인하고 수정
• 충돌 해결 후 커밋하여 병합 완료

Pull Request (PR)

정의: 자신의 변경 사항을 다른 브랜치에 병합해달라고 요청하는 GitHub의 협업 기능

Pull Request 프로세스

1. 기능 브랜치에서 작업 완료
2. GitHub에 푸시
3. Pull Request 생성
4. 팀원들의 코드 리뷰
5. 피드백 반영 및 수정
6. 승인 후 메인 브랜치에 병합

코드 리뷰의 이점

• 코드 품질 향상
• 지식 공유 및 학습
• 버그 조기 발견
• 팀 코딩 스타일 통일

Fork와 Clone

Fork (포크)

• 다른 사람의 저장소를 자신의 GitHub 계정으로 복사
• 원본 저장소와 독립적으로 작업 가능
• 오픈소스 프로젝트 기여 시 주로 사용

Clone (클론)

• 원격 저장소를 로컬 컴퓨터로 복사
• git clone <repository-url> 명령 사용
• 로컬에서 작업 후 원격 저장소에 푸시

차이점

• Fork: GitHub 서버 간 복사 (웹에서 수행)
• Clone: GitHub → 로컬 컴퓨터 복사 (명령줄에서 수행)

Issue (이슈)

정의: 버그 리포트, 기능 요청, 질문 등을 추적하고 관리하는 도구

Issue 활용

• 버그 발견 시 상세 내용 기록
• 새로운 기능 제안 및 토론
• 작업 할당 및 진행 상황 추적
• 라벨, 마일스톤으로 분류 및 관리

Issue와 Pull Request 연결

• 커밋 메시지에 #이슈번호 포함
• PR 설명에 Closes #이슈번호 작성
• PR 병합 시 자동으로 이슈 종료

1.4 GitHub 명령어 종류

Git과 GitHub를 사용하기 위한 필수 명령어들을 카테고리별로 정리합니다. 명령줄 인터페이스(CLI)를 통해 효율적으로 버전 관리를 수행할 수 있습니다.

저장소 초기화 및 복제

새 저장소 생성

git init

• 현재 디렉토리를 Git 저장소로 초기화
• .git 폴더 생성 (버전 관리 정보 저장)

원격 저장소 복제

git clone <repository-url>

• GitHub의 저장소를 로컬로 복사
• 자동으로 원격 저장소 연결 설정

예시

git clone https://github.com/username/repository.git

변경 사항 추적 및 커밋

파일 상태 확인

git status

• 수정된 파일, 스테이징된 파일 확인
• 현재 브랜치 정보 표시

변경 사항 스테이징

git add <파일명>          # 특정 파일 추가
git add .                 # 모든 변경 파일 추가
git add *.js              # 특정 패턴 파일 추가

커밋 생성

git commit -m "커밋 메시지"
git commit -am "메시지"    # add + commit 동시 수행

커밋 이력 확인

git log                   # 전체 커밋 이력
git log --oneline         # 간략한 형식
git log --graph           # 그래프 형식

브랜치 관리

브랜치 생성 및 전환

git branch <브랜치명>           # 브랜치 생성
git checkout <브랜치명>         # 브랜치 전환
git checkout -b <브랜치명>      # 생성 + 전환
git switch <브랜치명>           # 브랜치 전환 (최신 방식)

브랜치 목록 확인

git branch                # 로컬 브랜치 목록
git branch -r             # 원격 브랜치 목록
git branch -a             # 모든 브랜치 목록

브랜치 삭제

git branch -d <브랜치명>        # 병합된 브랜치 삭제
git branch -D <브랜치명>        # 강제 삭제

병합 및 리베이스

브랜치 병합

git merge <브랜치명>

• 현재 브랜치에 다른 브랜치의 변경사항 병합
• 병합 커밋 생성

리베이스

git rebase <브랜치명>

• 커밋 이력을 선형으로 재정렬
• 깔끔한 히스토리 유지
• 주의: 공개된 브랜치에서는 사용 지양

충돌 해결

git status                # 충돌 파일 확인
# 파일 수정 후
git add <파일명>
git commit                # 병합 완료

원격 저장소 작업

원격 저장소 연결

git remote add origin <repository-url>
git remote -v             # 원격 저장소 목록 확인

변경사항 업로드

git push origin <브랜치명>
git push -u origin main   # 기본 브랜치 설정
git push --all            # 모든 브랜치 푸시

변경사항 다운로드

git fetch                 # 원격 변경사항 가져오기 (병합 X)
git pull                  # 가져오기 + 병합
git pull origin main      # 특정 브랜치에서 가져오기

원격 브랜치 추적

git checkout -b <로컬브랜치> origin/<원격브랜치>

변경 사항 되돌리기

작업 디렉토리 변경 취소

git checkout -- <파일명>   # 파일 변경 취소
git restore <파일명>       # 파일 복원 (최신 방식)

스테이징 취소

git reset HEAD <파일명>
git restore --staged <파일명>  # 최신 방식

커밋 되돌리기

git reset --soft HEAD~1   # 커밋만 취소, 변경사항 유지
git reset --mixed HEAD~1  # 커밋 + 스테이징 취소
git reset --hard HEAD~1   # 모든 변경사항 삭제

커밋 수정

git commit --amend        # 마지막 커밋 수정
git commit --amend -m "새 메시지"  # 메시지만 수정

특정 커밋 되돌리기

git revert <커밋해시>      # 새로운 커밋으로 되돌림

임시 저장 (Stash)

변경사항 임시 저장

git stash                 # 현재 변경사항 임시 저장
git stash save "메시지"    # 메시지와 함께 저장

임시 저장 목록 확인

git stash list

임시 저장 복원

git stash pop             # 가장 최근 stash 적용 + 삭제
git stash apply           # 적용만 하고 삭제 안함
git stash apply stash@{n} # 특정 stash 적용

임시 저장 삭제

git stash drop stash@{n}  # 특정 stash 삭제
git stash clear           # 모든 stash 삭제

태그 관리

태그 생성

git tag v1.0.0            # 경량 태그
git tag -a v1.0.0 -m "버전 1.0.0 릴리스"  # 주석 태그

태그 목록 확인

git tag                   # 모든 태그 목록
git tag -l "v1.*"         # 패턴 매칭

태그 푸시

git push origin v1.0.0    # 특정 태그 푸시
git push origin --tags    # 모든 태그 푸시

태그 삭제

git tag -d v1.0.0         # 로컬 태그 삭제
git push origin :refs/tags/v1.0.0  # 원격 태그 삭제

설정 및 도움말

사용자 정보 설정

git config --global user.name "이름"
git config --global user.email "이메일"

설정 확인

git config --list         # 모든 설정 확인
git config user.name      # 특정 설정 확인

별칭(Alias) 설정

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status

도움말

git help <명령어>
git <명령어> --help

0. Abstract

실세계 애플리케이션에서는 대규모 다변량 시계열 데이터가 광범위하게 활용되고 있으며, 이에 따라 다변량 시계열 이상 탐지는 다양한 산업 분야에서 핵심적인 역할을 수행하고 있다. 시계열 기반 이상 탐지는 설비 오작동을 사전에 감지하고 유지보수 비용을 절감함으로써 전반적인 시스템 생산성을 향상시키는 데 기여한다.

그러나 실제 시계열 데이터는 복잡한 비선형 시간적 종속성을 포함하고 있어, 정상 패턴을 정확히 모델링하는 것이 어렵다. 이러한 문제를 해결하기 위해서는 정상 동작의 시간적 동역학을 효과적으로 표현할 수 있는 풍부한 잠재 표현 학습이 필수적이다.

본 연구는 다중 해상도 앙상블(Multi-Resolution Ensemble)과 예측 코딩(Predictive Coding)을 결합한 비지도 다변량 시계열 이상 탐지 모델 RAE-MEPC를 제안한다. 제안 모델은 입력 시계열로부터 다양한 시간 스케일의 종속성을 포착하기 위해 다중 해상도 앙상블 인코딩 구조를 도입한다. 인코더는 서로 다른 인코딩 길이를 갖는 여러 서브 인코더로부터 추출된 시간적 특징을 계층적으로 집계하여, 정상 동작에 대한 다중 스케일 표현을 형성한다.

디코더는 이에 대응하는 다중 해상도 앙상블 디코딩 방식을 사용하여 입력 시계열을 재구성하며, 저해상도 표현이 고해상도 서브 디코더의 복원을 보조하는 구조를 갖는다. 또한 예측 코딩 모듈을 추가하여, 모델이 단순 재구성뿐 아니라 미래 시점 예측을 동시에 학습하도록 설계함으로써 시계열의 장기적 시간 의존성을 보다 효과적으로 반영한다.

1. Introduction

스마트 팩토리, 발전소, 사이버 보안 시스템과 같은 복잡한 산업 환경에서는 대규모 다변량 시계열 데이터가 지속적으로 축적되고 있다. 이러한 시스템의 안정적인 운영을 위해서는 작동 상태를 지속적으로 모니터링하고 잠재적인 위협을 조기에 식별하는 것이 중요하다. 특히 이상 징후에 대한 적절한 대응이 이루어지지 않을 경우 실제 사고로 이어질 수 있으며, 이는 상당한 경제적 손실과 운영 중단을 초래할 수 있다.

일반적으로 이상(anomaly)은 정상 관측 패턴에서 크게 벗어나는 데이터 포인트로 정의된다. 시계열 이상 탐지의 목적은 주어진 길이의 시계열 데이터에서 각 시점별 이상 여부를 판단하는 데 있다. 따라서 데이터를 지속적으로 생성하는 산업 시스템에서는 시스템 생산성을 향상시키기 위해 정확하고 신뢰할 수 있는 시계열 이상 탐지 모델이 요구된다.

효과적인 시계열 이상 탐지 방법은 정상 시계열 데이터에 내재된 비선형 시간적 정보를 충분히 포착하는 동시에, 사전에 관측되지 않은 이상 패턴까지 탐지할 수 있어야 한다. 그러나 이 문제는 여러 측면에서 어려움을 가진다.

첫째, 실제 환경에서는 이상 데이터의 수집이 매우 제한적이다. 이로 인해 대부분의 시계열 이상 탐지는 정상 데이터만을 이용한 비지도 학습 방식으로 수행된다. 둘째, 다변량 시계열 데이터는 복잡한 시간적 종속성과 확률적 변동성을 동시에 포함하고 있다. 기존 연구들은 이러한 문제를 해결하기 위해 정상 시계열의 장기적 종속성을 효과적으로 표현하는 잠재 표현 학습에 초점을 맞추어 왔다.

딥러닝 기반 시계열 이상 탐지 방법은 크게 예측 기반 방법과 재구성 기반 방법으로 구분된다.

예측 기반 방법은 과거 시계열을 입력으로 미래 값을 예측함으로써 정상 패턴을 학습한다. 이 접근은 정상 데이터로만 학습된 예측 모델이 비정상 패턴을 정확히 예측하지 못할 것이라는 가정에 기반한다. 추론 단계에서는 실제 관측값과 예측값 간의 오차가 사전에 정의된 임계값을 초과할 경우 해당 시점을 이상으로 판단한다. 이러한 방식은 시계열의 시간적 흐름을 직접적으로 모델링할 수 있다는 장점이 있다.

반면, 재구성 기반 방법은 정상 시계열 데이터를 잠재 공간으로 압축한 뒤 이를 다시 복원하는 과정을 통해 정상 패턴을 학습한다. 이 접근은 정상 데이터로만 학습된 모델이 이상 데이터를 제대로 재구성하지 못하며, 그 결과 재구성 오류가 크게 증가한다는 가정을 사용한다. 대부분의 재구성 기반 방법은 오토인코더 구조를 활용하며, 입력과 재구성 출력 간의 차이를 이상 점수로 사용한다.

일부 연구에서는 생성 모델을 결합하여 정상 데이터 분포를 보다 정밀하게 학습하려는 시도도 이루어지고 있다. 이러한 방법들은 생성자와 판별자 간의 적대적 학습을 통해 정상 분포를 모델링하고, 재구성 확률이 낮은 샘플을 이상치로 판단한다. 그러나 이 계열의 방법들은 학습 불안정성과 모드 붕괴 문제로 인해 실제 적용에서 제약이 존재한다.

본 연구에서는 예측 기반 접근과 재구성 기반 접근의 장점을 결합하여 보다 유익한 시계열 표현을 학습하기 위해, 다중 해상도 앙상블과 예측 코딩을 결합한 순환 오토인코더 모델 RAE-MEPC를 제안한다.

제안 모델은 인코딩 및 디코딩 단계 모두에서 서로 다른 시간 해상도를 활용하여 시계열의 다중 스케일 종속성을 학습한다. 인코더는 서로 다른 인코딩 길이를 갖는 여러 서브 인코더로 구성되며, 각 서브 인코더는 서로 다른 시간 스케일의 특징을 추출한다. 짧은 인코딩 길이는 전역 패턴을 포착하는 데 유리하며, 긴 인코딩 길이는 보다 세밀한 국소 패턴을 포착한다. 이후 이 특징들은 계층적으로 통합되어 최종 잠재 표현을 형성한다.

디코딩 단계에서는 다중 해상도 앙상블 구조를 통해 입력 시계열을 재구성하며, 가장 높은 해상도의 출력이 최종 재구성 결과로 사용된다. 또한 재구성 디코더와 함께 예측 디코더를 추가하여, 과거 잠재 특징으로부터 미래 시계열을 예측하도록 학습한다. 이를 통해 모델은 단순 재구성뿐 아니라 시간적 예측 관점에서도 정상 패턴을 학습하게 된다.

모델이 정상 데이터로 학습된 이후에는 입력 시계열과 재구성 결과 간의 차이를 기반으로 이상 여부를 판단한다.

본 연구의 주요 기여는 다음과 같다.

• 다변량 시계열의 다중 스케일 종속성을 학습하기 위한 다중 해상도 앙상블 인코딩 구조를 제안한다.
• 재구성과 예측을 동시에 수행하는 예측 코딩 메커니즘을 도입하여 시간적 표현 품질을 향상시킨다.
• 단변량 및 다변량 시계열 데이터셋 전반에서 기존 벤치마크 모델 대비 우수한 이상 탐지 성능을 확인한다.

2. Method

본 연구에서 제안된 방법은 인코딩된 특징들을 기반으로 입력 시계열을 재구성하고 미래 시계열을 예측하여 정상 패턴을 학습하는 것을 목표로 한다. 데이터는 다변량 시계열이며, 훈련 데이터의 대부분은 정상이라는 가정하에 기반하여 비지도 학습 방식으로 이상치를 탐지한다. 제안된 모델은 인코더와 두개의 디코더로 구성되며, 두 개의 디코더는 각각 입력 시계열을 재구성하고 미래 타임스텝을 예측하기 위해 사용된다.

2.1 Network 구조

2.1.1 Multi-Resolution Ensemble Encoding

제안된 모델의 인코더의 목표는 여러 스케일에서 입력 시계열로부터 시간적 특징을 추출하는 것이다. 인코더는 서로 다른 길이를 가진 $$K^E$$ 개의 서브 인코더를 가진다. k번째 서브 인코더 $$E_k$$ 는 길이 $$T^{(E_k)}$$ 의 시계열에서 시간적 특징을 포착한다. 이 인코딩의 길이는 식 (1) 에 표시된 대로 정의된다.

여기서 $$\tau > 1$$은 인코딩 길이를 결정하는 하이퍼파라미미터이며, 각 서브 인코더는 자신의 인코딩 길이와 일치하는 길이를 가진 시계열을 받는다. 원본 입력 시계열의 다중 스케일 종속성을 학습하기 위해 각 서브 인코더의 입력은 원본 입력과 유사한 형태를 가진다. 따라서 각 서브 인코더의 입력 시퀀스 $$x^{(E_k)}$$ 는 식 (2)에 표시된 대로 원본 시간 창 X를 길이 $$T^{E_k}$$의 부분 시퀀스로 다운 샘플링하여 얻는다.

제안된 모델의 모든 서브 인코더는 LSTM이ek.

짧은 인코딩 길이를 가진 저해상도 서브인코더는 거시적인 시간적 특성을 추출하고, 더 긴 인코딩 길이를 가진 고해상도 서브 인코더는 지역적인 시간적 패턴에 집중할 수 있다. 마지막으로 통합된 인코딩 표현은 낮은 해상도 ~ 높은 해상도 까지의 마지막 은닉 상태를 계층적으로 집계하여 얻어진다.

여기서 $$\text{MLP}(E_{k} - E_{k+1})$$ 는 $$E_k$$ 와 $$E_{k+1}$$의 정보를 통합하는 fully connected Layer이다. $$h^{(E_k)}{T(E_k)}$$ 는 $$E_k$$ 의 마지막 은닉 상태이고 $$h^{(E_k)}$$는 $$E{K(E)}$$부터 $$E_k$$까지 통합된 특징이다. $$h^(E)$$ 는 모든 서브 인코더의 출력 앙상블로 부터 얻어진 최종 인코딩 representation이다. 이로써 RAE-MEPC의 인코더는 다중 해상도 앙상블 인코딩을 도입하여 general 하고 local 특징을 모두 가진 다중 스케일 종속성을 포착할 수 있다.

2.1.2 Multi-Resolution Ensemble Decoding

디코딩은 인코딩의 역순으로 입력 시계열을 구성한다. 서브 디코더의 해상도는 서브 인코더와 동일하며, 각 서브 디코더는 teacher forcing 없이 최종 인코딩된 표현을 기반으로 디코딩 길이의 입력 시계열을 재구성한다.

추가로 각 서브 디코더에는 LSTM 입력에 작은양의 노이즈가 추가되는데, 입력 패턴의 부분적 손상에 대한 강건성을 향상시키기 위함이다.

여기서 $h(RD_k){t+1}$는 서브 디코더 $RD_k$의 이전 은닉 상태이며, $h(RD{k+1}){\left[t/\tau\right]}$는 더 거친 해상도를 갖는 인접 서브 디코더 $RD_{k+1}$의 해당 은닉 상태이다.

$\beta$는 더 거친 디코더의 정보를 반영하는 정도를 조절하는 하이퍼파라미터이다. 더 작은 $\beta$ 값을 사용함으로써 각 디코딩 단계에서 저해상도 정보가 보다 적극적으로 활용되도록 설정하였다.

이 과정을 통해 재구성 디코더는 상위 해상도의 출력을 생성할 때, 더 거친 해상도의 정보를 직접 참조함으로써 다중 해상도 정보를 효과적으로 통합할 수 있다.

다중 해상도 앙상블 디코딩 이후, 역순으로 재구성된 입력 시계열은 최고 해상도 디코더로부터 획득된다. 마지막으로, 식 (12)에 나타낸 바와 같이 재구성 디코더의 출력을 다시 역순으로 변환하여 최종 재구성 출력 $Y_{\text{recon}}$을 얻는다.

2.1.3 Predictive Coding

본 연구에선, 입력 시계열의 장기 의존성을 추출하기 위해 predictive coding 을 도입한다. 예측 디코더의 목표는 인코더로부터 압축된 표현을 기반으로 T/2시점 이후의 미래 시계열을 예측하는 것이다. 제안된 모델에서 예측 디코더는 다음과 같이 예측 작업을 수행한다.

여기서 $h^{(PD)}_t$와 $y^{(PD)}_t$는 각각 예측 디코더의 $t$번째 시점에서의 은닉 상태와 예측된 출력이다. $\text{MLP}^{(PD)}$는 출력 생성을 위한 완전 연결 계층(fully connected layer)이며, $\text{LSTM}^{(PD)}$는 시간적 의존성을 모델링하기 위해 예측 디코더 내부에 사용된 LSTM 모델이다.

마지막으로, 예측 디코더는 식 (16)에 나타낸 바와 같이 $T/2$ 시점 이후의 미래 시계열 $\vec{Y}_{pred}$를 예측한다. 예측 디코더는 예측 작업의 관점에서 시간적 의존성을 반영함으로써, 인코더가 정상 시계열로부터 보다 유익한 잠재 패턴을 학습하도록 유도한다.

2.2 Objective Function

제안된 모델의 손실함수는 세가지 항으로 구성되는데,

1. 재구성 오류 $L_{\text{recon}}$
2. 다중 Shape Constraint Loss $L_{\text{shape}}$
3. 예측 오류 $L_{\text{pred}}$

Reconstruction Loss

재구성 손실 $L_{\text{recon}}$은 입력 시계열과 최고 해상도 서브 디코더 $RD_1$의 재구성 출력 간 평균 제곱 오차로 정의된다.

$$ L_{\text{recon}} = \sum_{t=1}^{T} | y^{(RD_1)}_t - x_t |_2^2 $$

이 손실은 재구성된 출력이 원본 입력 시계열과 최대한 유사하도록 유도한다.

Shape Constraint Loss

다중 해상도 형상 강제 손실 $L_{\text{shape}}$은 RAMED에서 제안된 방식으로, 서로 다른 해상도의 서브 디코더들이 입력 시계열과 일관된 시간적 추세를 학습하도록 유도하기 위해 도입되었다.

다중 해상도 앙상블 디코딩 구조에서는 각 서브 디코더가 서로 다른 시간 스케일의 출력을 생성하므로, 모든 해상도에서 입력과 유사한 패턴을 유지하는 것이 중요하다. 이미 $L_{\text{recon}}$이 최고 해상도 출력의 재구성을 보장하므로, $L_{\text{shape}}$은 이를 제외한 나머지 서브 디코더들에 대해서만 정의된다.

이 손실은 서로 다른 길이의 시계열 간 거리를 계산할 수 있는 DTW 기반으로 정의되며, DTW의 비미분 가능 문제를 해결하기 위해 smoothed DTW (sDTW)를 사용한다.

sDTW는 다음과 같이 정의된다.

$$ sDTW(X, \overleftarrow{Y}^{(RD_k)}) = -\gamma \log \sum_{A \in \mathcal{A}} e^{-\langle AC\rangle/\gamma} $$

여기서 $A$는 DTW 정렬 경로 행렬이며, $C$는 두 시계열 간 유클리드 거리로 구성된 정렬 비용 행렬이다. $\gamma$는 스무딩 강도를 제어하는 하이퍼파라미터이다.

이를 기반으로 $L_{\text{shape}}$는 다음과 같이 정의된다.

$$ L_{\text{shape}} = \frac{1}{K(RD)-1} \sum_{k=2}^{K(RD)} sDTW(X, \overleftarrow{Y}^{(RD_k)}) $$

이 손실은 서로 다른 해상도의 서브 디코더들이 입력과 유사한 시간적 구조를 유지하도록 강제한다.

Prediction Loss

예측 손실 $L_{\text{pred}}$는 예측 디코더의 출력과 실제 미래 시계열 간 평균 제곱 오차로 정의된다.

$$ L_{\text{pred}} = \sum_{t=1}^{T} | y^{(PD)}t - x{t+\lceil T/2 \rceil} |_2^2 $$

이 손실은 예측 디코더가 $T/2$ 시점 이후의 미래 시계열을 정확히 예측하도록 유도하며, 동시에 인코더가 예측에 유용한 추가적인 시간 정보를 학습하도록 돕는다.

Total Loss

위 세 가지 손실 항을 결합하여 RAE-MEPC의 총 손실은 다음과 같이 정의된다.

$$ L_{\text{total}} = L_{\text{recon}} + \lambda_{\text{shape}} L_{\text{shape}} + \lambda_{\text{pred}} L_{\text{pred}} $$

여기서 $\lambda_{\text{shape}}$와 $\lambda_{\text{pred}}$는 각각 형상 손실과 예측 손실의 중요도를 조절하는 하이퍼파라미터이다.

3. 현업 아이디어 적용

방법1. 해상도 분할

• S를 기준으로 해상도를 분할하여, 각 서브 인코더가 입력받는 s를 해당 S의 중요 s만 한정하거나 Attention을 추가하여 학습하도록 함
• 만약, 도메인 지식으로 추가한다면, 입력에 중요도를 직접 곱하여 추가하며 손실함수에도 이를 반영 (중요도 높은 s에 더 큰 패널티 부여식으로..)

방법2. S(t-1) -> S(t) 를 예측하는 모델

• 두 단계의 물리적 인과관계를 학습하여 S간의 관계를 학습하게 함

+) 추가 방법 손실 함수에 R set값 추가

• 단, rd 만 하는 값도 존재하기 때문에 이 부분은 고려 필요

0. Abstract

산업 자동화와 IoT 기술의 급속한 발전으로 공장 환경에서는 대규모 다차원 시계열 데이터가 지속적으로 생성되고 있다. 이러한 환경에서 이상 탐지는 설비 고장, 생산 중단, 비용 손실을 방지하기 위한 핵심 기술로 자리 잡았다. 따라서 이상 탐지 알고리즘은 높은 정확도뿐 아니라, 이상을 유발한 특정 센서 또는 장비를 신속히 식별할 수 있는 해석 가능성을 동시에 요구받는다.

그러나 기존 신경망 기반 이상 탐지 모델들은 다차원 시계열 데이터에 포함된 차원 내 시간적 특징과 차원 간 관계적 특징을 동시에 효과적으로 포착하지 못하는 한계를 가진다. 또한 두 특징을 모두 고려하는 일부 복잡한 모델은 이상 원인을 설명하지 못해 실제 산업 현장 적용에 어려움이 있다.

본 연구에서는 이러한 문제를 해결하기 위해, 변이형 오토인코더(VAE)를 기반으로 한 해석 가능한 이상 탐지 모델인 MCA-VAE(Multi-Channel Multi-Scale Convolution Attention Variational Autoencoder)를 제안한다. 제안 모델은 다중 스케일 가중치 공유 컨볼루션을 통해 각 차원의 시간적 특징을 추출하고, 멀티 헤드 어텐션 메커니즘을 활용하여 센서 간 관계적 특징을 모델링한다. 이후 추출된 특징을 VAE 잠재 공간에 매핑하고 재구성 오차를 기반으로 이상을 탐지한다.

또한 VAE의 확률 분포 특성을 활용하여 각 센서별 조건부 확률을 계산함으로써, 이상 발생 원인을 센서 단위로 해석할 수 있는 메커니즘을 제공한다. 실험 결과, 제안 모델은 산업 제어 데이터셋에서 AUC 0.982, F1 점수 0.905를 기록하며 기존 베이스라인 대비 우수한 성능을 보였고, 동시에 정확한 이상 원인 분석 능력을 확인하였다.

1. Introduction

최근 산업 제어 시스템은 IoT 기술과 네트워크 인프라의 발전으로 인해 점점 더 많은 센서와 장비가 연결되는 구조로 변화하고 있다. 이러한 변화는 생산 공정의 자동화와 정밀 모니터링을 가능하게 하지만, 동시에 시스템 전반의 위험도를 증가시키는 요인이 된다.

현대 제조 공장에서는 다수의 센서와 액추에이터가 동시에 동작하며 고차원 다변량 시계열 데이터를 생성한다. 이 데이터는 설비 상태를 실시간으로 반영하지만, 이상 상황이 발생할 경우 빠르게 전체 시스템으로 전파될 수 있다. 예를 들어 특정 센서의 비정상 값이 즉시 탐지되지 않을 경우, 국소적 고장이 전체 생산 라인으로 확산되어 심각한 가동 중단과 경제적 손실로 이어질 수 있다.

이러한 배경에서 이상 탐지 알고리즘은 단순한 이벤트 감지를 넘어 다음과 같은 요구 조건을 충족해야 한다.

• 다차원 시계열에서 높은 탐지 정확도를 유지할 것
• 이상 발생 시점을 명확히 식별할 것
• 이상을 유발한 센서 또는 장비를 함께 제공할 것

그러나 기존 방법들은 다음과 같은 구조적 한계를 가진다.

첫째, 많은 모델이 차원 내 시간적 특징과 차원 간 관계적 특징 중 하나에만 집중한다. 일부 모델은 개별 센서의 시간 패턴을 잘 학습하지만 센서 간 상호작용을 충분히 반영하지 못하며, 반대로 관계 구조에 집중한 모델은 각 센서의 세밀한 시간 변화를 놓치는 경우가 많다.

둘째, 두 특징을 모두 고려하는 모델이라 하더라도 해석 가능성이 부족한 경우가 대부분이다. 이러한 모델은 특정 시점에서 이상이 발생했음을 알려줄 수는 있지만, 실제로 어떤 센서가 문제의 원인인지 설명하지 못한다. 이는 산업 현장에서 유지보수 엔지니어가 즉각적인 조치를 취하는 데 큰 제약이 된다.

결과적으로, 기존 다변량 시계열 이상 탐지 기법은 다음 두 가지 측면에서 개선이 필요하다.

1. 시간적 특징과 관계적 특징을 동시에 효과적으로 모델링할 수 있는 구조
2. 이상 발생 원인을 센서 단위로 제공할 수 있는 해석 가능성

본 연구는 이러한 문제를 해결하기 위해 MCA-VAE 모델을 제안한다. 제안된 방법은 다중 스케일 컨볼루션을 통해 각 센서의 시간 패턴을 추출하고, 멀티 헤드 어텐션을 활용하여 센서 간 관계를 학습한다. 이후 VAE 기반 확률 모델을 통해 이상을 탐지하며, 재구성 확률 분해를 통해 센서별 이상 점수를 산출한다.

이를 통해 기존 방법이 가지는 정확도와 해석 가능성의 트레이드오프를 완화하고, 실제 산업 제어 환경에서 활용 가능한 이상 탐지 프레임워크를 제시하는 것을 목표로 한다.

2. Methods

시계열 이상치 탐지는 대상에 따라 단변량과 다변량으로 나눌 수 있다.

단변량 시계열 이상치 유형은 점 이상치와 패턴 이상치라는 두 가지 주요 범주로 나눌 수 있다. 연속된 점들의 집합은 패턴 이상치를 유발하며, 이는 주기 이상치와 모양 이상치, 추세 이상치로 더 세분화 될 수 있다.

다변량 시계열의 이상치 유형은 세 가지 범주로 나눌 수 있다. 여기엔 단변량의 가장 일반적인 이상치 유형도 속하, 상관 이상치와 상관-시간 이상치라는 두 가지 고유한 이상치 유형이 있다. 상관 이상치는 여러 지표 간의 관계가 갑작스러운 변화를 겪었거나 과거 관계를 위반 했음을 나타낸다. 상관-시간 이상치는 상관 이상치와 시간 이상치를 모두 포함하며 탐지하기 가장 쉬운 이상치 유형이다.

현재 이상치 탐지 모델들은 시계열 데이터의 각 차원을 모델링하는 데 집중하여 시계열 데이터 내의 차원 간 상관 관계를 무시하거나, 차원 간 상관관계를 추출하기 위해 복잡한 구조를 사용하지만, 각 차원 데이터의 시간 종속성에 대한 상세한 모델링 과정이 부족하다는 것을 이 논문에서는 문제점으로 지적한다. 따라서 더 나은 이상치 탐지 정확도를 달성하기 위해 차원 내 시간 종속성과 차원 간 상관관계를 동시에 모델링 하는 것을 제안한다.

• $$X = {X_1, \dots, X_N }$$: 데이터 셋
• $$X \in \mathbb{R}^{M \times N}$$ : 연속적인 관측치를 등간격 샘플링 한 것
• M : 차원수
• N : 데이터 길이
• $$X_i$$ : 하나의 차원
• $$X_t$$ : 하나의 관측치

여기서 Multi-Variate Time Series 길이에 문맥 정보를 통합하고, 이상치 결과를 계산하기 위해 $$W$$ 길이의 슬라이딩 윈도우를 적용한다. 이상치 탐지는 관측된 결과이상이 발생한 원인을 (어떤 센서가 이상인지) 찾아내는 것을 목표로 한다.

2.1 Network 구조

모델은 위의 그림에서 나타낸 바와 같이 세 부분으로 구성된다.

1. 다중 스케일 가중치 공유 컨볼루션 네트워크(Multi-Scale Weight Sharing Convolutional Network)
   • 이는 서로 다른 시간 스케일에서 특징을 효과적으로 포착할 수 있다.
   • 작은 Conv 커널은 단기 시계열 특징을 포착할 수 있으며, 큰 Conv 커널은 장기 시계열 특징을 포착할 수 있다.
   • 또한, 다중 채널 지역 가중치 공유 방법은 정확도를 보장하면서 매개변수 수를 최대한 줄일 수 있다.

2. 다중 헤드 어텐션 메커니즘(Multi-Head Attention Mechanism)
   • 서로 다른 데이터 차원 간의 상호 영향을 유연하게 파악하여, 차원 간의 관계 특징을 모델이 포착하도록 돕는다.

3. 개선된 변이형 오토인코더(Improved Variational Autoencoder, VAE)

• 제안된 KL Divergence 최적화 방법은 VAE 모델 학습이 더 나은 특징 추출 결과를 달성하도록 한다.
• 또한 VAE 모델의 확률 분포는 이상치 해석에 사용된다.

2.1.1 Multi-Scale Weight Sharing Convolutional Network

기존의 1D CNN 모델은 단일 채널 시계열 데이터에만 적합하며 , 여러 상관된 채널의 정보를 완전히 활용하지 못한다. 다중 채널 1D CNN 모델은 여러 개의 독립적인 Conv 커널을 사용하여 각 채널에 대해 Conv 연산을 수행한 후, 각 채널의 Conv 결과를 병합한다. 이 접근 방식은 여러 차원에서 시간적 특징을 동시에 추출하고 병합 연산을 통해 다중 채널 정보를 완전히 활용하여 모델의 성능과 정확도를 향상시킬 수 있다.

이를 적용하기 위해 각 입력 데이터 채널을 독립적으로 처리하기 위하여 다중 채널 커널 K를 생성해야 하는데, 이 수식은 아래와 같다.

• $$n_c$$ : 데이터의 채널 수
• $$X_c$$ : 시점 t-i+1에서의 h번째 채널 측정 값

단일 채널에 대한 Conv 과 다른 점은 모든 채널에 대한 추가적인 합산이 다르다는 점이다. 다중 채널 Conv에서는 각 채널에 대해 Conv 커널이 설정되며, 각 Conv 커널의 가중치 수가 더 많아져 모델 파라미터가 커지고 학습 속도가 느려지며 과적합 위험이 증가한다.

때문에 이 논문에서는 개선된 다중 스케일 가중치 공유 Conv 방법을 제안하는데, 많은 파라미터와 특징 추출 효과 사이의 균형과 다른 시간 스케일에 적응하지 못하는 문제를 해결하기 위해 가중치 공유 방법을 제안한다. (다른 시간 스케일에 적응하지 못하는 문제란, 하나의 고정된 크기의 커널은 모든 시간 스케일의 특징을 동시에 잘 포착하기 어렵다는 말이다.)

가중치 공유는 서로 다른 위치에 있는 Conv 커널에 동일한 파라미터를 사용하는 것을 의미한다. 이 방법은 각 Conv 커널의 파라미터 수를 단일 Conv 커널과 동일한 수로 압축할 수 있어, 신경망의 파라미터 수를 크게 줄일 수 있다.

구체적으로, 컨볼루션 레이어에 k개의 컨볼루션 커널이 포함되어 있고, 각 컨볼루션 커널의 크기가 $$h \times w$$ 이며, 입력 채널 수가 $$c_{in}$$ 이고, 출력 채널 수가 $$c_{out}$$이라고 가정하면,

가중치 공유 방법을 사용하지 않으면 이 레이어의 파라미터 수는 $$k \times h \times w \times c_{in} \times c_{out}$$이다. 하지만 가중치 공유 방법을 사용하면 이 레이어의 파라미터 수는 $$k \times h \times w$$ 에 불과하다. 따라서 가중치 공유는 파라미터 수를 크게 줄여 모델의 복잡성을 감소시키고 모델의 학습 속도 및 일반화 성능을 향상시킬 수 있다.

하지만 global 가중치 공유 방법은 모든 conv 커널이 동일한 가중치 행렬을 사용하기 때문에 학습이 불충분하다는 문제가 있다.

이런 문제를 해결하기 위해 이 논문에선 추가로 local 가중치 공유 방법을 제안한다. local 가중치 공유는 가중치 행렬을 여러개의 지역 가중치 행렬로 분해하며, 지역 가중치 행렬은 독립적으로 조정될 수 있다.

수식 (2)는 global 가중치 공유 식이며, (3)은 local 가중치 공유 식이다. 여기서 $$W^{(i,j)}_{m,n,l,k}$$는 좌표 (i, j)에서의 지역 가중치 행렬 내 가중치를 나타낸다. 논문 저자들은 데이터 간의 상관관계를 분석하여 상관관계가 강한 다차원 데이터에 대해 먼저 동일한 지역 가중치 행렬을 사용한다고 한다. (→ 내가 지금 적용하고자 하는 아이디어에는 센서들을 그룹화 해서 step 별로 사용하면 될 것 같다.)

2.1.2 Implementation of the Multi-Scale Convolutional Network

고정된 Conv 커널이 특정 스케일의 특징만 포착할 수 있다는 문제를 해결하기 위해 데이터셋에서 다양한 시간 스케일의 고도로 표현력 있는 잠재 특징을 추출하기 위한 다중 스케일 Conv 커널을 이 논문에선 추가로 제안한다. 여기선 세 개의 병렬 경롤르 가진 Conv 레이어를 구성하며, 각 경로는 서로 다른 커널 크기를 가지고, 각 Conv 레이어는 다중 Conv 방법을 사용한다.

논문에선 공장 데이터는 단기적인 규칙성(단일 센서 스케일에서 제품이 공정에 들어가거나 나가는 순간을 고려), 중기적인 패턴(단일 공정 내에서 발생하는 생산 공정을 고려), 그리고 장기적인 변화(운송, 생산, 검사를 포함하여 한 제품에서 다음 제품까지의 전체 주기를 고려)를 포함하여 이 세가지 상황을 포괄하기 위해 주기를 짧은주기, 중간 주기, 긴주기로 크기를 선택했다고 한다. (→ 이 부분을 내 현업 도메인 지식에 맞춰 설명 가능하고 해석 가능한 주기로 변경하면 좋을 것 같다.)

이후 Conv 및 풀링 후 얻어진 특징 벡터들은 연결되어 새로운 전역 특징 벡터 행렬을 형성하는데, 이후 어텐션 메커니즘은 이런 계층적 특징으로 부터 유횽한 정보를 추출한다. 다양한 스케일의 Conv 레이어를 사용하여 특징을 추출한 후, 데이터 공간 차원을 줄이고 가장 중요한 특징을 유지하기 위해 특징 선택 및 다운 샘플링을 수행한다. 여기선 맥스 풀링을 사용하여 특징 맵에 대한 다운 샘플링 연산을 수행한다.

여기서 $$c_k$$ 는 k의 커널을 사용하여 추출된 특징 맵을 나타내고, , $$\hat{c}_k$$는 샘플링 후의 특징 맵을 나타낸다. ![] (https://velog.velcdn.com/images/you_n_sunny/post/29a75a97-183e-4a38-aa5d-aaf1cb545675/image.png)

이후 전역 특징 벡터 행렬 T는 추가 처리를 위해 멀티헤드 어텐션 메커니즘 입력으로 사용된다.

2.1.3 Multi-Head Attention Mechanism

차원 간의 상관 관계 특징을 포착하기 위해, 이전 단계에서 얻은 컨볼루션 네트워크로부터 유용한 정보를 추가로 추출하기 위해 멀티 헤드 어텐션 메커니즘을 사용한다. 단계는 다음과 같다

1. 먼저 이전 Conv 네트워크에서 얻은 전역 특징 벡터 행렬 T로 부터 행렬 Q, K, V를 초기화한다.
2. Scaled Dot-product Attention(SDA)를 이용하여 Q와 K의 내적을 계산하여 유사도를 구한 다음, 내적의 결과가 너무 커지는 것을 방지하기 위해 $$d_k$$ 에 루트를 씌운 값으로 나눈다. (여기서 $$d_k$$는 행렬 $$k$$의 차원))
3. 이후 softmax 함수를 이용하여 정규화 한다.
4. 행렬 V와 곱하여 어텐션 표현을 얻는다.

이를 이용한 아이디어로 서로 다른 파라미터 $$W_{Q_i}, W_{K_i}, W_{V_i}$$를 사용하여 행렬 Q, K, V 에 선형 변환을 수행하고, 그 결과를 SDA에 입력한다. 헤드 i부터 h까지의 결과들을 하나의 행렬로 연결하고 파라미터 W를 곱하여 최종 선형 변환을 완료하여 식(8)에 나타난 멀티 헤드 어텐션 메커니즘의 최종 출력을 얻는다.

2.1.4 Improved Variational Autoencoder

이 논문에선 전역적인 관점에서 다중 변수의 정보를 모델링하고 다른 차원 간의 종속성을 더 잘 포착하기 위해, 어텐션 메커니즘의 출력을 VAE 모델의 잠재 공간으로 매핑한다. 그러나 일반적인 VAE가 확률적 경사 하강법(SGD)과 같은 최적화 방법을 사용하여 VAE를 훈련할 때, 인코더는 각 입력을 잠재 분포의 고정된 점으로 매핑하는 경향이 있기 때문에, 이로 인해 VAE의 KL divergence 가 상수화되어 잠재 변수와 더 이상 관련이 없게 되므로 효과적으로 최적화될 수 없다. 이 문제를 해결하기 위해 이 논문에선 수정된 Evidence Lower Bound (ELBO) 표현과 재매개변수화 최적화를 갖춘 개선된 VAE 방법을 제안한다.

위의 식은 기존 VAE의 손실함수 ELBO이며, 여기서 $$E_{q_\phi(z|X)}$$는 입력 X가 주어졌을 때 z의 기댓값을 나타낸다. $$KL({q_\phi(z|X)} | p(z))$$ 는 사후 분포 $$q_\phi(z|X)$$와 사전 분포 $$p(z)$$간의 KL divergence를 나타낸다. 그러나 실제에서는 KL divergence 의 가중치가 너무 크거나 데이터셋의 분포와 사전 분포간의 많은 차이가 있는 경우, 모델은 샘플 간의 다양성을 무시하고 입력 샘플을 잠재 공간의 작은 영역으로 매핑하는 경향이 있다. 이 문제를 해결하기 위해 논문에서는 ELBO의 첫번째 항인 재구성 오류를 최적화 하고 더 많은 가중치를 부여한다. 수정된 식은 아래와 같은데

여기서 베타는 재구성 오류와 KL divergence 오류의 상대적 중요도를 제어하는데 사용한다. 만약 베타가 작으면, 모델은 재구축에 더 집중하여 입력 데이터를 더 정확하게 복원하는데 능숙해진다. 하지만 잠재 공간이 너무 압축되어 잠재 변수의 다양성이 줄어들고 새로운 데이터를 생성하는 능력이 떨어질 수 있다. 반대로 베타가 크다면 잠재 공간의 여러 지점에서 샘플링 했을 때 생성되는 데이터가 다양성을 가지게 되기 때문에 정상 데이터를 완벽하게 복원하는 능력이 떨어질 수 있다.

2.1.5 Anomaly Explanation Based on Reconstruction Probability

이 논문에선 이상확률에 대해 계산하여 비정상 스코어를 계산할 수 있도록 하는 방법또한 제안하였는데, 알고리즘이 이상 설명 기능을 제공하여 엔지니어가 비정상 장치를 신속하게 탐지할 수 있도록, VAE의 확률론적 이론을 결합하고 이상 설명을 위해 재구성 확률을 사용한다.

여기서 $$f_\theta$$는 VAE의 디코더를 나타내고, $$\theta$$는 디코더의 매개변수를 나타냅니다. 그런 다음 각 차원의 재구성 확률 $$P_\theta(x_i^t | Z_{t-T:t})$$를 계산한다. (잠재 변수 조건 $$Z_{t-T:t}$$가 주어졌을 때 i번째 차원의 $$x_t$$에 대한 확률)

이후, 가우시안 분포를 통해 $$\hat{x}_i^t$$의 확률 밀도 함수 값을 계산한다.

이상 점수가 이상을 직관적으로 표시하기 위해

재구성 확률에 음수 로그 변환을 적용한다. 여기서 $$s_i^t$$ 는 i번째 차원에서 입력샘플 $$x_t$$의 이상 점수를 나타내며, 이상 점수가 높을 수록 해당 샘플은 더 비정상임을 나타낸다.

3. 현업 아이디어 적용

이 논문에서 제안된 방법을 응용하여 현업 문제에 적용을 해야한다. 크게 3가지 방식으로 적용할 수 있는데, 구체화는 팀원들과 논의한 후에 ..!

방법 1. S 별 Attention Masking

• Attention Mask 를 적용하여 S에 따라 동적으로 생성되게 한다.
• 중요 센서간(i,j)의 관계에서만 학습이 되도록 변환
• 이 방법은 논문에서 제안한 구조에서 크게 바뀌지 않는다.

방법 2. S별로 Multi Scale Convolution Network를 만들어 학습

• 모든 센서 공통 CNN 와, 특정 S에만 활성화되는 S 전용 필터를 병렬로 두어 S의 데이터가 들어오면, S번에 할당된 컨볼루션 필터들만 활성화되어 특징을 추출
• 입력데이터와 S 임베딩을 결합하여 게이트를 만드는 방식으로, S에서 중요한 s의 신호는 증폭, 나머지는 억제한 상태로 Conv 에 전달
• Attention Head 자체를 S에 할당하여 최종 특징 벡터 생성
• 이후 특징 벡터를 VAE의 잠재공간 z로 보낼 때 S를 다시 결합하여 z에서 S별로 Cluster 가 다르게 형성되도록 함

방법 3. VAE의 Latent 를 S 별로 분리 (조건부 입력)

• S별로 다른 Latent 분포 학습
• $$\text{ELBO}(S) = E_{q_\phi(z|x, S)}[\log p_\theta(x|z, S)] - \beta KL(q_\phi(z|x, S) | p(z|S))$$

+) 이 글로 사내에서 세미나를 했는데 아주 Hot했습니다..^^

1. 메모리 최적화 기법

메모리 최적화는 대용량 데이터 처리의 첫 번째 관문입니다. Pandas는 기본적으로 가장 큰 데이터 타입을 사용하기 때문에 메모리가 낭비되며, 적절한 최적화 없이는 메모리 부족 오류가 발생할 수 있습니다.

1.1 데이터 타입 최적화

Pandas에서 메모리 사용량을 줄이는 가장 효과적인 방법은 데이터 타입을 최적화하는 것입니다. 기본 int64를 int32로, float64를 float32로 변환하면 메모리 사용량을 절반으로 줄일 수 있습니다.

# 데이터 타입 확인
print(df.dtypes)

# 정수형 컬럼 최적화
df['id'] = df['id'].astype('int32')  # int64 → int32

# 범주형 데이터 변환
df['category'] = df['category'].astype('category')

# 메모리 사용량 확인
print(df.memory_usage(deep=True))

왜 int64 → int32, float64 → float32 로 바꾸면 메모리가 절반이 되는가?

이 현상은 Pandas의 특수한 동작 때문이 아니라, 컴퓨터가 숫자를 저장하는 방식에서 비롯됩니다.

컴퓨터에서 모든 숫자는 이진수(bit) 형태로 저장되며, 각 데이터 타입은 고정된 크기를 가집니다.

• 1 byte = 8 bits

대표적인 타입의 메모리 크기는 다음과 같습니다.

즉, int64와 float64는 각각 8바이트,
int32와 float32는 4바이트를 사용합니다.

따라서 동일한 개수의 값이 있을 때,
64비트 타입을 32비트 타입으로 변경하면 각 원소가 차지하는 메모리가 정확히 절반이 됩니다.

Pandas의 Series와 DataFrame 컬럼은 내부적으로 NumPy 배열(ndarray) 위에 저장됩니다.
이는 곧, 컬럼 하나가 연속된 메모리 블록으로 구성되며 모든 값이 동일한 dtype을 사용한다는 의미입니다.

이 때문에 컬럼의 메모리 사용량은 다음과 같이 계산됩니다.

전체 메모리 = row 수 × dtype 크기

예를 들어 1,000,000개의 값이 있을 경우:

• int64: 약 8MB
• int32: 약 4MB

차이는 정확히 2배입니다.

그렇다면 Pandas는 왜 기본적으로 int64와 float64를 사용할까요?

첫 번째 이유는 표현 가능한 값의 범위입니다.

int32는 약 ±21억까지만 표현할 수 있지만,
int64는 훨씬 큰 값을 다룰 수 있습니다. 실무 데이터에서는 ID, timestamp, 누적 카운트 등이 쉽게 int32 범위를 초과할 수 있기 때문에, Pandas는 안전한 기본값으로 int64를 선택합니다.

두 번째 이유는 float64가 과학 계산의 표준이기 때문입니다.
float64는 약 15자리 십진 정밀도를 제공하지만, float32는 약 7자리 수준에 불과합니다. 머신러닝이나 통계 계산에서는 오차 누적을 방지하기 위해 float64가 기본으로 사용됩니다.

실제 환경에서는 이 차이가 더욱 크게 체감됩니다.

수백만 row와 수십 개 이상의 컬럼을 가진 데이터셋에서는,
float64 대신 float32를 사용하는 것만으로도 수백 MB에서 수 GB 단위의 메모리를 절약할 수 있습니다.

이 차이는 단순한 저장 공간뿐 아니라:

• 데이터 로딩 속도
• CPU 캐시 효율
• 연산 성능
• 메모리 부족(OOM) 발생 여부

에도 직접적인 영향을 줍니다.

정리하면, int64 → int32, float64 → float32 변환 시 메모리가 절반으로 줄어드는 이유는 각 값이 차지하는 비트 수가 64에서 32로 감소하기 때문입니다.

Pandas는 고정 폭 dtype을 사용하는 연속 메모리 구조를 가지므로, 이러한 차이가 전체 메모리 사용량에 그대로 반영됩니다.

데이터 타입 최적화는 단순한 미세 조정이 아니라, 대용량 데이터 처리에서 가장 먼저 고려해야 할 구조적 최적화입니다.

1.2 다운캐스팅 (Downcasting)

앞서 수동으로 astype()을 사용해 데이터 타입을 변경할 수도 있지만,
Pandas는 보다 안전하게 타입을 축소할 수 있도록 pd.to_numeric()의 downcast 옵션을 제공합니다.

다운캐스팅은 현재 값들을 표현할 수 있는 가장 작은 숫자 타입으로 자동 변환하는 과정입니다.

df['value'] = pd.to_numeric(df['value'], downcast='integer')
df['price'] = pd.to_numeric(df['price'], downcast='float')

downcast는 무엇을 하는가?

downcast 옵션은 단순히 int64를 무조건 int32로 바꾸는 기능이 아닙니다.

Pandas는 다음과 같은 순서로 동작합니다.

1. 컬럼 전체 값을 스캔
2. 최소값과 최대값 계산
3. 해당 범위를 표현할 수 있는 가장 작은 dtype 선택
4. 안전할 경우에만 변환 수행

예를 들어 downcast='integer'를 사용하면 내부적으로 다음 후보들을 검사합니다.

• int8
• int16
• int32
• int64

그리고 실제 값의 범위가 int8에 들어가면 int8, int16에 들어가면 int16, 그보다 크면 int32 … 이런 식으로 자동 선택합니다.

float 역시 동일하게:

• float16
• float32
• float64

중에서 가능한 가장 작은 타입을 선택합니다.

즉, downcast는 “값을 잃지 않는 범위 내에서 최소 메모리 타입을 찾는 과정”입니다.

astype과 downcast의 차이

astype()은 개발자가 dtype을 직접 지정합니다.

df['id'] = df['id'].astype('int32')

이 방식은 빠르고 단순하지만, 값 범위를 벗어나면 overflow가 발생하거나 에러가 날 수 있습니다.

반면 downcast는 자동 검사 후 변환하기 때문에 상대적으로 안전합니다.

즉:

• astype → 수동, 빠름, 위험 가능
• downcast → 자동, 안전, 약간 느림

대량 데이터에서는 downcast가 실수 가능성을 크게 줄여줍니다.

왜 downcast가 실무에서 중요한가?

실제 데이터에서는 다음과 같은 경우가 많습니다.

• 0~100 범위의 카운트 값
• 작은 정수 범위의 코드 값
• 소수점 두 자리 가격 정보

이런 컬럼들이 기본적으로 int64 / float64로 로딩되면 필요 이상의 메모리를 차지합니다.

downcast를 적용하면:

• int64 → int8 / int16
• float64 → float32

까지 자동으로 축소되는 경우가 많아, 수십 퍼센트 이상의 메모리 절감 효과를 얻을 수 있습니다.

주의할 점

float downcast는 정밀도 손실 가능성이 있습니다.

float32는 약 7자리 십진 정밀도만 유지되므로, 아주 작은 차이가 중요한 금융 계산이나 통계 분석에서는 주의가 필요합니다.

또한 pd.to_numeric()은 문자열 컬럼도 숫자로 변환하려 시도하므로, 혼합 타입 컬럼에서는 의도치 않은 NaN이 생길 수 있습니다.

정리하면, downcasting은 컬럼의 실제 값 범위를 기반으로 가장 작은 dtype을 자동 선택하는 메커니즘이며, 대용량 데이터에서 메모리 최적화를 위한 매우 효과적인 첫 단계입니다.

특히 여러 컬럼을 동시에 처리해야 할 경우, 수동 astype보다 downcast 방식이 훨씬 안정적입니다.

1.3 범주형(Category) 데이터 활용

pandas에서 문자열 컬럼은 기본적으로 object 타입으로 저장됩니다. 이 경우 각 행마다 개별 Python 문자열 객체가 생성되며, 동일한 문자열이라도 반복해서 메모리에 저장됩니다. 이 구조는 대량 데이터에서 불필요한 메모리 사용을 유발합니다.

category 타입은 이러한 문자열 컬럼을 고유값 테이블(categories) 과 정수 인덱스 배열(codes) 로 분리하여 저장합니다. 고유 문자열은 한 번만 저장되고, 실제 데이터는 작은 정수로 참조됩니다.

즉 내부 구조는 다음과 같습니다.

• categories: 컬럼의 고유 문자열 목록
• codes: 각 행이 참조하는 정수 배열

이 방식은 반복되는 문자열을 직접 저장하지 않기 때문에, 고유값 수가 적은 컬럼에서 메모리 절감 효과가 큽니다.

# 범주형 변환 전후 메모리 비교
print(df['status'].memory_usage(deep=True))  # 변환 전
df['status'] = df['status'].astype('category')
print(df['status'].memory_usage(deep=True))  # 변환 후

카디널리티가 낮을수록(categories의 크기가 작을수록) 효과가 크며, 고유값이 많은 컬럼에서는 오히려 이점이 줄어들 수 있습니다. 따라서 상태값, 타입 코드, 플래그와 같은 반복 패턴이 있는 컬럼에 주로 적용하는 것이 적절합니다.

범주형 변환 시 내부 구조 변화

문자열 컬럼은 기본적으로 object 타입으로 저장됩니다. 이 경우 각 행마다 독립적인 Python 문자열 객체가 생성되며, 동일한 문자열이라도 반복해서 메모리에 저장됩니다.

예를 들어 다음과 같은 컬럼이 있을 때:

status
------
OK
FAIL
OK
OK
FAIL

pandas 내부에서는 다음과 같이 처리됩니다.

["OK", "FAIL", "OK", "OK", "FAIL"]

각 원소는 다음 구성 요소를 가집니다.

• Python object pointer (약 8 bytes)
• Python string 객체
• 문자열 길이만큼의 문자 버퍼

즉 전체 메모리는 대략 다음 형태가 됩니다.

행 수 N × (포인터 + 문자열 객체 + 실제 문자 데이터)

같은 "OK" 값이라도:

• 매 행마다 새로운 문자열 객체가 생성되고
• 매번 별도의 메모리가 할당됩니다.

이 구조 때문에 데이터가 커질수록 메모리 사용량이 빠르게 증가하며, memory_usage(deep=True) 값도 크게 나타납니다.

category dtype 적용 후 구조

df['status'] = df['status'].astype('category')

이렇게 변환하면 pandas는 컬럼을 두 부분으로 분리합니다.

(1) Categories (고유값 테이블)

Index(['FAIL', 'OK'])

컬럼의 고유 문자열만 별도로 저장하며, 각 문자열은 단 한 번만 메모리에 올라갑니다.

(2) Codes (정수 인덱스 배열)

원본 데이터:

OK, FAIL, OK, OK, FAIL

은 다음과 같이 정수로 변환됩니다.

[1, 0, 1, 1, 0]

이 배열은 numpy 기반의 정수 배열이며,

• int8 / int16 / int32 중 자동 선택
• 연속 메모리 구조
• Python object 없음

이라는 특징을 가집니다.

최종 메모리 구조

category 컬럼은 내부적으로 다음과 같이 구성됩니다.

• categories → ['FAIL', 'OK'] (고유 문자열만 저장)

• codes → [1, 0, 1, 1, 0] (순수 정수 배열)

정리하면:

변환 전:
N × string 객체

변환 후:
K × string  +  N × 작은 정수

여기서:

• N: 전체 행 수
• K: 고유값 개수 (cardinality)

입니다.

카디널리티가 낮을수록 효과가 큰 이유

예를 들어 1,000,000 rows가 있을 때,

고유값이 3개라면:

• categories: 문자열 3개
• codes: 정수 1,000,000개

으로 매우 큰 메모리 절감 효과를 얻습니다.

반면 고유값이 900,000개라면:

• categories: 문자열 900,000개
• codes: 정수 1,000,000개

가 되어 절감 효과가 거의 없으며, 오히려 성능이 나빠질 수도 있습니다.

따라서 category 타입은 상태값, 타입 코드, 플래그처럼 반복 패턴이 뚜렷한 low-cardinality 컬럼에 사용하는 것이 일반적입니다.

memory_usage(deep=True)가 줄어드는 이유

deep=True 옵션은 object 내부 문자열 메모리까지 모두 포함해 계산합니다.

category로 변환하면:

• 행 단위 문자열 객체가 제거되고
• 대신 numpy 정수 배열이 사용됩니다.

이 때문에 메모리 사용량이 눈에 띄게 감소하게 됩니다.

1.4 청크(Chunk) 단위 처리

대용량 CSV 파일을 pd.read_csv()로 한 번에 로드하면, 파일 전체가 메모리에 올라가게 됩니다. 이때 DataFrame은 단순히 파일 크기만큼의 메모리를 사용하는 것이 아니라, 파싱 과정에서 생성되는 Python 객체와 내부 버퍼까지 포함하여 더 많은 메모리를 요구합니다.

즉 다음과 같은 호출은:

df = pd.read_csv("large_file.csv")

내부적으로:

• 전체 파일을 메모리로 읽고
• 각 컬럼을 파싱하여 numpy 배열 또는 object 배열로 변환하며
• DataFrame 구조를 구성하기 위한 추가 메모리를 할당합니다.

파일 크기가 수 GB 이상이거나, 시스템 메모리가 제한적인 환경에서는 이 과정에서 쉽게 메모리 부족(OOM)이 발생할 수 있습니다.

chunksize 옵션을 사용하면 pandas는 파일을 한 번에 읽지 않고, 지정한 행 수 단위로 나누어 순차적으로 로드합니다.

chunk_size = 10000
for chunk in pd.read_csv('large_file.csv', chunksize=chunk_size):
    process_chunk(chunk)

이 방식에서는:

• 전체 파일을 메모리에 올리지 않고
• 일정 크기의 DataFrame만 반복적으로 생성하며
• 이전 청크는 처리 후 garbage collection 대상이 됩니다.

결과적으로 동시에 메모리에 존재하는 데이터의 크기가 chunk_size에 의해 제한됩니다.

내부적으로는 다음과 같은 흐름으로 동작합니다.

1. CSV 파일 스트림을 열고
2. 지정된 행 수만큼 읽어서 DataFrame으로 변환
3. 해당 청크를 iterator 형태로 반환
4. 다음 블록을 다시 읽는 과정을 반복

즉:

파일 → 작은 DataFrame → 처리 → 버림 → 다음 DataFrame

이라는 패턴으로 동작합니다.

이 방식의 핵심 장점은 메모리 사용량이 데이터 전체 크기가 아니라, 청크 크기에 의해 결정된다는 점입니다.

예를 들어:

• 전체 파일: 10GB
• chunksize: 10,000 rows

라면, 실제 메모리에는 항상 10,000행 정도만 존재하게 됩니다.

따라서 로그 데이터, 센서 데이터, 대규모 이벤트 로그처럼 파일 크기가 메모리를 초과하는 경우에도 안정적으로 처리가 가능합니다.

청크 처리는 특히 다음과 같은 상황에서 유용합니다.

• 전체 데이터를 한 번에 올릴 필요가 없는 집계 작업
• feature engineering을 단계적으로 수행하는 경우
• 모델 학습 전 전처리를 스트리밍 방식으로 처리할 때
• 메모리 제한이 있는 서버나 컨테이너 환경

정리하면, chunksize는 pandas가 제공하는 스트리밍 처리 방식이며, 대용량 데이터를 “로드”하는 대신 “순차 소비”하도록 구조를 바꿔주는 기능입니다. 메모리 제약 환경에서는 사실상 필수적인 접근 방식입니다.

1.5 불필요한 복사 최소화

pandas의 많은 연산은 기본적으로 새로운 DataFrame 또는 Series 객체를 생성합니다. 이는 함수형 스타일을 유지하기 위한 설계이지만, 대용량 데이터에서는 불필요한 메모리 사용으로 이어질 수 있습니다.

예를 들어 다음과 같은 코드에서:

subset = df[df['value'] > 100]

pandas는 조건에 맞는 행을 골라 완전히 새로운 DataFrame을 생성합니다. 이때 선택된 데이터는 원본과 메모리를 공유하지 않으며, 실제 값이 모두 복사됩니다.

즉 내부적으로는:

원본 DataFrame → 조건 필터 → 새 DataFrame 생성 → 데이터 복사

라는 흐름을 따릅니다.

행 수가 많을수록 이 복사 비용은 빠르게 증가합니다.

마찬가지로 다음과 같은 연산들도 대부분 새로운 객체를 반환합니다.

• groupby()
• merge()
• concat()
• assign()
• drop() (기본값)

이들은 모두 원본을 수정하지 않고 결과를 새로 만들어 돌려줍니다.

inplace 옵션

일부 메서드는 inplace=True 옵션을 제공합니다.

df.drop(columns=['unnecessary_col'], inplace=True)

이 경우 pandas는 기존 DataFrame 객체를 직접 수정하며, 별도의 결과 객체를 생성하지 않습니다. 따라서 불필요한 DataFrame 복사를 줄일 수 있습니다.

다만 내부 구현상 항상 완전한 zero-copy는 아니며, 컬럼 구조 변경이나 블록 재정렬이 필요한 경우에는 일부 메모리 재할당이 발생할 수 있습니다. 그럼에도 불구하고, 결과 객체를 하나 더 만드는 것보다는 메모리 사용이 훨씬 적습니다.

View와 Copy의 차이

numpy와 pandas는 개념적으로 view(참조) 와 copy(복사) 를 구분합니다.

• view: 원본 메모리를 그대로 참조
• copy: 새로운 메모리를 할당

열 단위 접근은 종종 view를 반환합니다.

col = df['value']

이 경우 대부분 원본 데이터 블록을 공유합니다.

반면 조건 필터링은 항상 copy입니다.

subset = df.loc[df['value'] > 100]

여기서는 boolean mask가 적용되며, 결과 DataFrame은 새 메모리를 할당합니다.

즉 “필요할 때만 복사한다”는 의미는, 가능하면 컬럼 단위 참조를 활용하고, 대규모 행 필터링을 반복적으로 수행하지 않는 구조를 만드는 것을 의미합니다.

실무 관점에서의 정리

대용량 DataFrame을 다룰 때는 다음 원칙이 도움이 됩니다.

• 불필요한 중간 DataFrame 생성을 피한다
• 가능한 경우 inplace 연산을 사용한다
• 컬럼 단위 접근을 우선한다
• 반복적인 조건 슬라이싱을 최소화한다
• 파이프라인 중간 결과를 무분별하게 변수로 저장하지 않는다

정리하면, pandas의 대부분 연산은 안전성을 위해 “복사 기반”으로 동작합니다. 작은 데이터에서는 문제가 되지 않지만, 대용량 환경에서는 이 복사 비용이 곧 메모리 병목이 됩니다. 따라서 연산 흐름을 설계할 때 객체 생성 횟수 자체를 줄이는 것이 중요합니다.

1.6 Python 객체의 메모리 오버헤드 이해

pandas 메모리 사용의 근본 원인은 Python 객체 자체의 구조에 있습니다. CPython에서 모든 객체는 단순한 값이 아니라, 메타데이터를 포함한 복합 구조로 관리됩니다.

예를 들어 하나의 Python 객체는 최소한 다음 정보를 포함합니다.

• 참조 카운트 (reference count)
• 타입 포인터 (type pointer)
• 객체 헤더

이 때문에 “값 하나”를 저장하더라도 상당한 고정 비용이 발생합니다.

실제로 일반적인 64bit CPython 환경에서의 대략적인 크기는 다음과 같습니다.

• 빈 문자열: 약 41 bytes
• 정수(int): 약 28 bytes
• 빈 리스트: 약 56 bytes
• 빈 딕셔너리: 약 64 bytes

여기에 실제 데이터가 추가되면 크기는 더 증가합니다.

즉 Python에서 다음과 같은 코드가 있다고 할 때:

values = [1, 2, 3, 4]

메모리에는 단순히 4 × int 만 존재하는 것이 아니라,

• 리스트 객체
• 포인터 배열
• 각 정수 객체

가 모두 별도로 생성됩니다.

구조적으로는 다음과 같습니다.

list object
 ├─ pointer → int object
 ├─ pointer → int object
 ├─ pointer → int object
 └─ pointer → int object

즉:

• 리스트는 포인터 배열을 들고 있고
• 각 숫자는 독립적인 Python 객체입니다.

이 방식은 유연성과 안전성 측면에서는 장점이 있지만, 대량 데이터 처리에서는 매우 비효율적입니다.

NumPy 배열이 메모리를 적게 사용하는 이유

반면 NumPy 배열은 Python 객체가 아니라, 연속된 C 메모리 블록 위에 순수 값만 저장합니다.

예를 들어 int64 배열의 경우:

• 각 원소는 정확히 8 bytes
• 추가 객체 헤더 없음
• 포인터 없음
• 연속 메모리 구조

입니다.

즉 다음과 같은 차이가 발생합니다.

Python list: N × (포인터 + Python int 객체)
NumPy array: N × 8 bytes

이 차이가 수백만 단위 데이터에서는 수십~수백 MB 이상의 격차로 이어집니다.

pandas에서 object 컬럼보다 numeric 컬럼이 훨씬 메모리 효율적인 이유도 동일한 원리입니다.

slots를 통한 객체 경량화

클래스 기반 구조에서도 기본 Python 객체는 __dict__ 를 사용하여 속성을 저장합니다.

class A:
    pass

이 경우 각 인스턴스는 내부에 딕셔너리를 하나씩 가지게 됩니다.

__slots__ 를 사용하면 이 딕셔너리를 제거하고, 고정 슬롯 기반 구조로 바꿀 수 있습니다.

class A:
    __slots__ = ("x", "y")

이 방식은:

• 객체당 메모리 사용량 감소
• 속성 접근 속도 개선

효과가 있으며, 대량 객체를 생성하는 경우 유의미한 차이를 만듭니다.

pandas에서 메모리 문제가 발생하는 이유는 단순히 DataFrame이 커서가 아니라, 내부에 수많은 Python 객체가 생성되기 때문입니다.

따라서 메모리 최적화의 핵심은 다음과 같습니다.

• object dtype을 피하고 numeric / category 타입을 사용한다
• 가능하면 NumPy 기반 구조를 활용한다
• 불필요한 DataFrame 복사를 줄인다
• 대량 객체 생성이 필요한 경우 __slots__ 등을 고려한다

결국 pandas 메모리 사용량은 “데이터 크기”보다 “Python 객체 개수”에 더 크게 좌우됩니다.

2. 속도 최적화 기법

처리 속도 최적화는 데이터 사이언스 워크플로우의 효율성을 결정합니다. Python은 편의성이 뛰어나지만 실행 속도가 느리다는 단점이 있으며, 특히 반복문 사용 시 성능 저하가 심각합니다.

2.1 벡터화(Vectorization) 연산 활용

Python에서 가장 큰 성능 병목은 반복문 자체가 아니라, Python 인터프리터가 개입하는 횟수입니다. for 루프를 사용한 순회 방식은 매 반복마다 Python 레벨의 연산과 타입 확인이 발생하며, 이 비용이 누적되면 전체 성능을 크게 저하시킵니다.

예를 들어 다음 코드를 보면:

result = []
for i in range(len(df)):
    result.append(df.iloc[i]['value'] * 2)

이 한 줄의 연산 안에는 다음 과정이 반복됩니다.

• Python for 루프 제어
• df.iloc[i] 인덱싱
• Series 생성
• 'value' 키 접근
• Python 정수 연산
• 리스트 append

즉 단순한 곱셈 연산 하나를 위해, 여러 단계의 Python 객체 접근과 함수 호출이 매번 발생합니다.

반면 벡터화 연산은 완전히 다른 실행 경로를 가집니다.

result = df['value'].values * 2

이 코드에서 핵심은 .values 를 통해 NumPy ndarray 를 사용하는 것입니다.

NumPy 배열은 다음과 같은 특징을 가집니다.

• 동일한 dtype의 값만 저장
• 연속된 메모리 구조
• Python 객체 없음

이 상태에서 수행되는 * 2 연산은 Python 반복문이 아니라, C로 구현된 내부 루프에서 실행됩니다.

즉 실행 흐름은 다음과 같습니다.

Python 호출 1회 → C 레벨 루프 → 전체 배열 연산

반복문이 Python 레벨에서 실행되지 않기 때문에, 인터프리터 오버헤드가 거의 발생하지 않습니다.

Python for loop와 벡터화의 본질적인 차이

두 방식의 차이는 연산 횟수가 아니라, 어디서 반복이 실행되느냐에 있습니다.

for loop:
Python → Python → Python → Python (N번)

Vectorization:
Python → C → C → C (N번)

Python은 동적 타입 언어이기 때문에, 각 연산마다 타입 확인과 참조 관리가 필요합니다. 반면 C 레벨에서는 타입이 고정되어 있으며, 연속 메모리 접근이 가능해 CPU 캐시 효율도 높습니다.

이 때문에 벡터화 연산은 일반적으로 Python 반복문 대비 수십 배 이상의 성능 차이를 보입니다.

pandas에서도 동일하게 적용되는 이유

pandas의 많은 연산은 내부적으로 NumPy를 기반으로 구현되어 있습니다. 따라서 다음과 같은 연산들은 대부분 벡터화되어 처리됩니다.

• 산술 연산 (+, -, *, /)
• 비교 연산
• boolean mask
• 통계 연산 (mean, sum, std 등)

가능한 경우 pandas Series나 DataFrame 전체에 대해 연산을 적용하는 것이, 행 단위 접근보다 훨씬 효율적입니다.

벡터화 연산이 빠른 이유는 “연산을 한 번에 처리해서”가 아니라, 반복을 Python이 아닌 C 레벨로 내려보내기 때문입니다.

따라서 성능이 중요한 코드에서는:

• Python for loop 기반 순회를 피하고
• NumPy ndarray 또는 pandas의 벡터화 연산을 사용하며
• 행 단위 처리보다는 컬럼 단위 연산을 우선하는 것이

기본적인 최적화 전략이 됩니다.

2.2 Pandas 내장 함수 우선 사용

pandas에서 제공하는 집계 함수(sum, mean, min, max 등)는 단순한 편의 기능이 아니라, NumPy 기반의 저수준(low-level) 루틴 위에 구현된 고성능 연산입니다.

예를 들어 다음 두 코드는 기능적으로 동일합니다.

# Python 반복문
total = 0
for value in df['column']:
    total += value

# Pandas 내장 함수
total = df['column'].sum()

하지만 내부 실행 방식은 완전히 다릅니다.

Python 반복문의 내부 동작

첫 번째 방식에서는 각 반복마다 다음 작업이 발생합니다.

• Python iterator 제어
• pandas Series에서 값 추출
• Python 객체로 변환
• Python 정수 연산
• 결과 저장

즉 매 원소마다 Python 인터프리터가 개입합니다.

구조적으로는 다음과 같습니다.

Python → Python → Python → Python (N번 반복)

데이터가 커질수록 이 인터프리터 오버헤드가 누적되어 성능이 급격히 저하됩니다.

Pandas 내장 함수의 실행 경로

반면 df['column'].sum() 은 내부적으로 NumPy 배열을 직접 참조하여 C 레벨 루프에서 연산을 수행합니다.

실행 흐름은 다음과 같습니다.

1. Series 내부의 ndarray 추출
2. NumPy reduce 함수 호출
3. C 코드에서 연속 메모리 순회
4. 결과 반환

즉:

Python 호출 1회 → C 레벨 루프 → 결과 반환

Python 인터프리터는 시작과 끝에만 관여하고, 실제 반복은 C에서 처리됩니다.

추가적인 최적화 요소

pandas/NumPy 내장 함수는 단순 반복 외에도 다음과 같은 최적화를 포함합니다.

• 연속 메모리 접근으로 CPU cache 효율 극대화
• SIMD(Vectorized instruction) 활용 가능
• dtype 기반 분기 제거
• 불필요한 Python 객체 생성 없음

이 때문에 같은 연산이라도 직접 작성한 Python 루프보다 수십 배 이상 빠른 경우가 일반적입니다.

pandas에서 성능을 확보하려면 기본 원칙은 단순합니다.

• 직접 반복문을 작성하지 않는다
• 내장 집계 함수와 벡터화 연산을 우선 사용한다
• row 단위 접근보다 column 단위 연산을 사용한다

정리하면, pandas 내장 함수가 빠른 이유는 “잘 만들어져 있어서”가 아니라, 연산이 Python이 아닌 C 레벨에서 수행되기 때문입니다. 따라서 동일한 작업이라면 항상 pandas/NumPy가 제공하는 연산을 먼저 고려하는 것이 바람직합니다.

2.3 apply() 대신 벡터화 연산 사용

apply() 는 pandas에서 제공하는 함수이지만, 내부적으로는 각 원소 또는 각 행에 대해 Python 함수를 반복 호출하는 구조입니다. 즉 벡터화 연산이 아니라, Python 레벨 반복문에 가깝게 동작합니다.

다음 예제를 보면:

df['result'] = df['value'].apply(lambda x: x * 2 + 1)

겉보기에는 pandas 연산처럼 보이지만, 실제로는 다음 과정이 반복됩니다.

• Series에서 값 하나 추출
• Python 객체로 변환
• lambda 함수 호출
• Python 산술 연산
• 결과 저장

이를 구조적으로 표현하면:

Python → lambda → Python → lambda → Python (N번)

즉 각 원소마다 Python 함수 호출이 발생하며, 인터프리터 오버헤드가 누적됩니다.

반면 벡터화 방식은 완전히 다른 경로를 사용합니다.

df['result'] = df['value'] * 2 + 1

이 코드는 내부적으로 Series가 보유한 NumPy ndarray를 직접 참조하여 C 레벨 루프에서 연산을 수행합니다.

실행 흐름은 다음과 같습니다.

Python 호출 1회 → NumPy C 루프 → 전체 배열 연산

Python은 연산 시작과 종료에만 관여하고, 실제 반복은 모두 C 코드에서 처리됩니다.

apply()가 특히 느려지는 이유

apply() 는 단순 반복 외에도 다음과 같은 추가 비용을 가집니다.

• 각 호출마다 Python 함수 객체 실행
• dtype 추론
• 결과를 다시 Series로 재구성

특히 lambda 함수나 사용자 정의 함수(UDF)를 사용할 경우, JIT 컴파일이나 벡터화 최적화가 적용되지 않기 때문에 성능 차이가 더 커집니다.

가능하면 다음 우선순위를 따르는 것이 일반적입니다.

1. pandas / NumPy 내장 벡터화 연산
2. pandas 집계 함수
3. NumPy 함수
4. 최후의 수단으로 apply()

즉 apply() 는 편의 기능이지, 성능을 위한 도구는 아닙니다.

정리하면, apply() 가 느린 이유는 pandas 함수라서가 아니라, Python 함수가 원소 단위로 반복 호출되기 때문입니다. 동일한 연산이 벡터화로 표현 가능하다면, 항상 벡터화 방식을 우선 사용하는 것이 바람직합니다.

2.4 NumPy와 Pandas의 메모리 공유 활용

pandas는 독립적인 데이터 구조처럼 보이지만, 실제로는 대부분의 numeric 컬럼이 NumPy ndarray 위에 직접 구성되어 있습니다. 즉 Series와 DataFrame은 내부적으로 NumPy 배열을 감싸는 thin wrapper에 가깝습니다.

따라서 다음과 같은 변환은 기본적으로 데이터를 복사하지 않습니다.

array = df['column'].values

이 경우 array 는 새로운 배열이 아니라, 기존 Series가 사용 중이던 NumPy 메모리를 그대로 참조합니다.

이를 직접 확인하면:

import numpy as np
np.shares_memory(df['column'], df['column'].values)  # True

True가 반환되며, 이는 pandas와 NumPy가 동일한 메모리 블록을 공유하고 있음을 의미합니다.

내부 구조 관점에서의 설명

numeric Series는 대략 다음 구조를 가집니다.

Series
 └─ NumPy ndarray (실제 데이터)

.values 또는 .to_numpy() 를 호출하면, 이 ndarray에 대한 참조만 반환됩니다.

즉:

복사 발생 ❌
포인터 전달 ✅

이기 때문에 변환 비용이 거의 없습니다.

NumPy 연산을 직접 사용하는 이유

NumPy 함수들은 연속 메모리 위에서 C 레벨 루프를 사용하여 동작합니다.

result = np.sqrt(array)

이 연산은:

• Python 반복문 없음
• pandas 오버헤드 없음
• dtype 고정
• SIMD 최적화 가능

이라는 특징을 가지며, pandas Series 메서드보다도 빠른 경우가 많습니다.

특히 복잡한 수치 계산이나 커스텀 연산이 필요한 경우, ndarray로 변환한 뒤 NumPy 연산을 적용하는 방식이 가장 효율적인 경로가 됩니다.

주의할 점

메모리 공유는 numeric dtype에서만 안전하게 적용됩니다.

object dtype 컬럼의 경우 .values 는 object 배열을 반환하며, 이 경우 각 원소는 여전히 Python 객체입니다. 따라서 기대하는 성능 향상이 발생하지 않을 수 있습니다.

또한 .to_numpy(copy=True) 를 명시하면 실제 복사가 발생하므로, 메모리 절약이 목적이라면 기본 옵션을 유지하는 것이 좋습니다.

pandas와 NumPy는 동일한 메모리를 공유하므로, .values 또는 .to_numpy() 를 사용하면 복사 없이 ndarray를 얻을 수 있습니다. 이를 활용하면 pandas 구조를 거치지 않고 NumPy의 고성능 연산을 직접 사용할 수 있으며, 대용량 데이터 처리 시 성능과 메모리 효율을 동시에 개선할 수 있습니다.

2.5 캐싱(Caching) 활용

연산이 느린 이유가 반복 계산 때문이라면, 가장 효과적인 최적화는 동일한 계산을 다시 수행하지 않는 것입니다. functools.lru_cache 는 함수 호출 결과를 메모리에 저장해 두었다가, 동일한 입력이 들어오면 즉시 반환하는 방식의 캐싱 메커니즘을 제공합니다.

from functools import lru_cache

@lru_cache(maxsize=128)
def expensive_computation(n):
    # 복잡한 계산
    return result

이후 동일한 인자로 함수를 호출하면:

result = expensive_computation(100)  # 첫 호출: 실제 계산 수행
result = expensive_computation(100)  # 두 번째 호출: 캐시에서 즉시 반환

두 번째 호출부터는 함수 내부 코드가 실행되지 않습니다.

lru_cache의 내부 동작

lru_cache 는 함수 입력을 key로, 반환값을 value로 하는 딕셔너리 기반 캐시를 유지합니다.

구조적으로는 다음과 같습니다.

(arguments) → result

이미 계산된 입력이 다시 들어오면:

• 함수 본문 실행 ❌
• 캐시 lookup ✅
• 저장된 결과 반환

이라는 흐름을 따릅니다.

maxsize 는 캐시에 저장할 최대 항목 수를 의미하며, 이를 초과하면 가장 오래 사용되지 않은 항목(LRU: Least Recently Used)부터 제거됩니다.

언제 효과적인가

캐싱은 다음 조건을 만족할 때 가장 효과적입니다.

• 동일한 입력으로 함수가 반복 호출되는 경우
• 계산 비용이 lookup 비용보다 훨씬 큰 경우
• 함수가 순수 함수(pure function)에 가까운 경우 (같은 입력 → 항상 같은 출력)

예를 들어:

• feature engineering 중 반복되는 변환
• 복잡한 규칙 기반 계산
• 동일 파라미터로 여러 번 호출되는 통계 함수

같은 상황에서 유의미한 성능 개선을 얻을 수 있습니다.

주의할 점

캐싱은 메모리를 사용합니다. 따라서:

• 입력 종류가 매우 많은 경우
• 결과 객체가 큰 경우
• 한 번만 호출되는 함수인 경우

에는 오히려 메모리 낭비가 될 수 있습니다.

또한 pandas DataFrame이나 NumPy 배열처럼 mutable 객체는 lru_cache의 key로 사용할 수 없으므로, 스칼라 값이나 immutable 타입 위주로 사용하는 것이 일반적입니다.

lru_cache 는 계산을 빠르게 만드는 도구라기보다, 계산 자체를 생략하게 만드는 도구입니다. 반복 호출되는 고비용 함수가 있다면, 벡터화나 C 레벨 최적화보다 캐싱이 더 큰 효과를 주는 경우도 많습니다.

3. 데이터 구조별 접근 패턴 최적화

Pandas와 NumPy는 서로 다른 메모리 레이아웃을 가지며, 이를 이해하고 활용하면 성능을 크게 향상시킬 수 있습니다.

3.1 Pandas: Column-major 접근

Pandas DataFrame은 컬럼 우선(column-major) 방식으로 데이터를 저장합니다. 따라서 컬럼 단위 연산이 행 단위 연산보다 훨씬 빠릅니다.

# 빠른 방법: 컬럼 단위 연산
df['new_col'] = df['col1'] + df['col2']

# 느린 방법: 행 단위 순회
for idx, row in df.iterrows():
    df.at[idx, 'new_col'] = row['col1'] + row['col2']

컬럼 단위 연산은 메모리 지역성(locality)이 좋아 캐시 효율이 높습니다.

3.2 NumPy: Row-major 접근 (C-order)

NumPy 배열은 기본적으로 행 우선(row-major, C-order) 방식으로 저장됩니다. 행 단위로 접근할 때 메모리 지역성이 좋습니다.

import numpy as np

# C-order (row-major): 행 단위 접근이 빠름
array_c = np.array([[1, 2, 3], [4, 5, 6]], order='C')

# F-order (column-major): 컬럼 단위 접근이 빠름
array_f = np.array([[1, 2, 3], [4, 5, 6]], order='F')

# 행 단위 연산 (C-order에서 빠름)
for row in array_c:
    process(row)

왜 Pandas는 컬럼 단위가 빠르고, NumPy는 행 단위가 빠른가?

이 차이는 단순히 라이브러리 구현 방식 때문이 아니라, 메모리에 데이터가 배치되는 방식과 CPU 캐시 동작 원리에서 비롯됩니다.

핵심은 다음 두 가지입니다.

• 메모리 레이아웃 (Memory Layout)
• 메모리 지역성 (Memory Locality)

이를 Pandas와 NumPy 관점에서 각각 살펴보겠습니다.

Pandas: Series 기반 Column-major 구조

Pandas DataFrame은 내부적으로 여러 개의 Series로 구성되어 있습니다. 각 컬럼은 독립적인 NumPy 배열로 존재하며, 메모리 상에서 연속적으로 저장됩니다.

즉 구조적으로 보면 다음과 같습니다.

DataFrame
 ├── Series(col1)
 ├── Series(col2)
 ├── Series(col3)

따라서 다음과 같은 연산은

df['col1'] + df['col2']

실제로는 다음 과정을 거칩니다.

• col1 전체 배열을 한 번에 읽고
• col2 전체 배열을 한 번에 읽은 뒤
• 벡터화 연산으로 처리합니다.

이 과정에서는

• 연속 메모리 접근이 이루어지고
• CPU cache line에 자연스럽게 적재되며
• Python loop 없이 C 레벨에서 계산됩니다.

결과적으로

• 분기(branch)가 없고
• cache miss가 최소화되며
• SIMD 벡터 연산이 활용됩니다.

매우 이상적인 실행 경로입니다.

반면 다음과 같은 코드에서는

for idx, row in df.iterrows():

완전히 다른 접근 패턴이 발생합니다.

이 경우 각 row는 새로운 Series 객체로 생성되며, 컬럼마다 서로 다른 메모리 위치를 참조하게 됩니다. 또한 Python 레벨 loop와 attribute access가 반복됩니다.

즉 다음과 같은 비용이 동시에 발생합니다.

• 객체 생성 비용
• 포인터 점프 증가
• cache locality 붕괴

따라서 iterrows 기반 접근은 구조적으로 느릴 수밖에 없습니다.

정리하면 Pandas에서는 다음과 같습니다.

• 컬럼 단위 연산: 연속 메모리 + 벡터화
• 행 단위 순회: 분산 메모리 + Python loop

이 차이가 곧 성능 차이로 이어집니다.

NumPy: 기본 Row-major (C-order) 메모리 배치

NumPy 배열은 기본적으로 C-order, 즉 row-major 방식으로 저장됩니다.

예를 들어 다음 배열은

[[1,2,3],
 [4,5,6]]

메모리에 다음과 같이 배치됩니다.

1 2 3 4 5 6

첫 번째 행이 끝까지 연속적으로 저장됩니다.

따라서 다음과 같은 행 단위 접근은

for row in array:

내부적으로 연속 메모리를 순차적으로 읽게 됩니다. 이때 CPU prefetch가 제대로 작동하고, cache hit 비율도 높아집니다.

반면 컬럼 단위 접근은 다음과 같은 패턴이 됩니다.

1 → 4 → 2 → 5 → 3 → 6

이처럼 stride jump가 발생하면

• cache line 활용도가 떨어지고
• TLB miss가 증가하며
• prefetch가 실패합니다.

이 때문에 NumPy에서 컬럼 접근은 상대적으로 느립니다.

물론 order='F' 옵션으로 column-major 배열을 만들 수 있지만, 대부분의 NumPy 연산과 C-extension은 C-order 기준으로 최적화되어 있습니다.

중요한 점은 이 모든 차이가 연산 복잡도가 아니라 메모리를 어떻게 읽느냐에서 발생한다는 사실입니다.

CPU에서는 계산보다 메모리 접근이 훨씬 느립니다.

따라서 성능의 본질은 다음에 달려 있습니다.

• 얼마나 연속적으로 읽을 수 있는가
• cache line을 얼마나 효율적으로 사용하는가

이를 정리하면 다음과 같습니다.

• Pandas는 컬럼이 연속 메모리이므로 컬럼 단위 연산이 빠릅니다.
• NumPy는 행이 연속 메모리이므로 행 단위 접근이 빠릅니다.

이 구조를 거스르는 순간 성능은 급격히 저하됩니다.

때문에

• Pandas에서는 항상 컬럼 벡터 연산을 사용합니다.
• NumPy에서는 메모리 order에 맞는 접근 방향을 유지합니다.
• Python loop는 최후의 수단으로 사용합니다.

이는 단순한 코딩 스타일 문제가 아니라, CPU 아키텍처 레벨에서 결정되는 물리적인 제약에 가깝습니다.

3.3 데이터 구조 선택 가이드

NumPy와 Pandas는 각각 다른 강점을 가지므로 작업 특성에 맞게 선택해야 합니다.

NumPy 사용이 적합한 경우:

• 수치 연산 및 시뮬레이션
• 선형 대수, 푸리에 변환
• 동일한 타입의 대량 데이터 처리

Pandas 사용이 적합한 경우:

• 테이블 형식 데이터 분석
• 데이터 로딩, 재구성, 피벗, 병합
• 누락된 데이터 처리
• 다양한 타입의 컬럼 관리

4. 최적화 전략

이론적 지식을 실제 프로젝트에 적용하기 위한 단계별 전략입니다.

4.1 최적화 우선순위 결정

최적화 우선순위:

1. 프로파일링으로 병목 지점 식별
2. 가장 많은 시간/메모리를 소비하는 부분부터 최적화
3. 측정 → 최적화 → 재측정 사이클 반복
4. 가독성과 성능의 균형 유지

4.2 단계별 최적화 접근법

복잡한 최적화 기법보다는 간단하고 효과적인 방법부터 적용합니다.

1단계: 저비용 최적화

• 데이터 타입 최적화
• 범주형 데이터 변환
• 불필요한 컬럼 제거

2단계: 알고리즘 개선

• 반복문을 벡터화 연산으로 변경
• Pandas 내장 함수 활용
• NumPy 연산 활용

3단계: 구조적 변경

• 청크 단위 처리 도입
• 병렬 처리 적용
• 데이터 파이프라인 재설계

5. 고급 최적화 기법

기본 최적화로 충분하지 않을 때 적용할 수 있는 고급 기법들입니다.

5.1 __slots__ 활용

Python 클래스에서 __slots__를 사용하면 인스턴스의 메모리 사용량을 크게 줄일 수 있습니다.

# 일반 클래스 (딕셔너리 기반)
class RegularClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

# __slots__ 사용 클래스
class SlottedClass:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 메모리 사용량 비교
import sys
regular = RegularClass(1, 2)
slotted = SlottedClass(1, 2)
print(f"Regular: {sys.getsizeof(regular.__dict__)} bytes")
print(f"Slotted: {sys.getsizeof(slotted)} bytes")

5.2 딕셔너리와 집합의 효율적 사용

딕셔너리와 집합은 해시 테이블 기반으로 O(1) 조회 성능을 제공합니다.

# 느린 방법: 리스트에서 검색 (O(n))
if item in my_list:  # 선형 탐색
    process(item)

# 빠른 방법: 집합에서 검색 (O(1))
my_set = set(my_list)
if item in my_set:  # 해시 테이블 조회
    process(item)

대량의 조회 작업이 필요한 경우 리스트를 집합이나 딕셔너리로 변환하는 것이 효과적입니다.

하지만 실제 실무에서는 단순히 "빠르게 만든다"는 이유만으로 적용했다가, 메모리 사용량 증가나 예상치 못한 정합성 문제를 겪는 경우도 적지 않다고 한다. 때문에 lru_cache 의 판단 기준에 대해서 학습한 내용을 이 글에 다루고자 한다.

1. lru_cache의 역할

lru_cache는 Python 표준 라이브러리 functools에 포함된 데코레이터로, 함수 호출 결과를 메모리에 저장해 두었다가 동일한 입력이 다시 들어오면 계산을 생략하는 구조를 제공한다.

중요한 점은, 이것이 알고리즘을 바꾸는 최적화가 아니라는 점이다. 계산 자체는 동일하며, 단지 이미 계산된 결과를 재사용할 수 있을 때만 실행 경로를 단축한다.

따라서 lru_cache는 다음과 같은 선택을 코드에 명시적으로 추가하는 것과 같다.

같은 입력이 다시 들어올 가능성이 높고, 그때 계산을 다시 하는 비용보다 메모리에 결과를 보관하는 비용이 더 저렴하다.

이 전제가 성립하지 않으면, lru_cache는 기대한 효과를 내지 못한다.

2. 내부 동작을 기준으로 이해하기

2.1 Cache key는 어떻게 만들어지는가

lru_cache는 함수가 호출될 때, 전달된 모든 positional argument와 keyword argument를 묶어 하나의 key로 사용한다. 이 key는 내부적으로 dictionary의 key로 사용되므로, 다음 조건을 만족해야 한다.

• 모든 인자는 hashable해야 한다
• 값이 같으면 항상 같은 hash를 가져야 한다

이 때문에 list, dict, DataFrame과 같은 mutable 객체는 그대로 인자로 사용할 수 없다.

또한 인자의 값이 조금이라도 다르면, 논리적으로 같은 의미라 하더라도 완전히 다른 cache entry로 취급된다.

2.2 Cache에 저장되는 것은 무엇인가

lru_cache는 함수의 반환값을 그대로 저장한다. 복사본을 만들거나, 약한 참조를 사용하는 것이 아니다.

즉, 반환 객체가 크다면:

• 해당 객체는 eviction 될 때까지 메모리에 유지되고
• 그 객체가 참조하는 모든 내부 구조 역시 메모리를 점유한다

DataFrame, 대형 numpy array, 복잡한 dict를 반환하는 함수에 lru_cache를 적용할 경우, 이는 곧 메모리 상주 객체 수를 늘리는 결정이 된다.

2.3 LRU 이 실제로 의미하는 것

maxsize는 단순히 "최대 몇 개"를 의미하지 않는다. 이는 다음을 의미한다.

• 최근에 사용된 항목은 남는다
• 한동안 호출되지 않은 항목은 제거된다

즉, 호출 패턴이 국소적(locality)을 가질수록 효과가 커지고, 호출 패턴이 넓게 퍼져 있을수록 eviction이 잦아진다.

호출이 다음과 같은 형태라면:

A → B → C → A → B → C

LRU는 매우 효과적으로 동작한다. 반면,

A → B → C → D → E → F → ...

와 같은 패턴에서는 cache는 거의 도움이 되지 않는다.

3. 언제 lru_cache를 써야 하는 가

3.1 반복 호출이 구조적으로 보장되는 경우

단순히 "여러 번 호출될 수도 있다"는 추측이 아니라, 코드 구조상 반복 호출이 발생할 수밖에 없는 경우가 있다.

예를 들어:

• 동일한 설정 값을 여러 컴포넌트에서 참조
• 동일한 경로의 데이터를 여러 후처리 단계에서 재사용
• 파라미터 조합이 제한적인 전처리 함수

이러한 경우에는 cache hit 비율이 높게 유지될 가능성이 크다.

3.2 계산 비용이 명확히 큰 경우

lru_cache는 cache miss 시에는 아무런 이득이 없다. 따라서 miss가 발생했을 때의 비용이 충분히 커야 한다.

대표적인 예는 다음과 같다.

• 디스크 I/O
• 네트워크 호출
• 복잡한 데이터 전처리 파이프라인

이 경우 hit 한 번이 가져오는 이득이 매우 크기 때문에, 비교적 적은 hit 비율도 의미를 가질 수 있다.

3.3 결과의 최신성이 절대적이지 않은 경우

lru_cache는 외부 상태 변화를 감지하지 않는다. 따라서 다음과 같은 전제가 필요하다.

• 한 run 동안 결과가 변하지 않아도 무방하다
• 약간 오래된 결과가 시스템 전체에 영향을 주지 않는다

이 조건이 충족되지 않는다면, cache 무효화 전략이 없는 lru_cache는 적절한 도구가 아니다.

4. 피해야 할 사용 패턴

4.1 외부 상태에 의존하는 함수

파일, DB, 환경 변수 등 외부 상태에 의존하는 함수는 인자만으로 결과가 결정되지 않는다.

이 경우 lru_cache는 실제 상태와 불일치하는 값을 반환할 수 있으며, 이는 디버깅이 매우 어려운 버그로 이어진다.

4.2 반환 객체가 크고 hit 비율이 낮은 경우

DataFrame을 반환하는 함수에 cache를 적용할 때 가장 흔히 발생하는 문제다.

• hit이 거의 없음
• eviction 이전까지 메모리에 상주
• 전체 프로세스 메모리 사용량 증가

이 경우 cache는 최적화가 아니라 메모리 사용에 부담이 된다.

4.3 인스턴스 메서드에 대한 무비판적 적용

인스턴스 메서드에 lru_cache를 적용하면 self가 key에 포함된다. 이는 다음을 의미한다.

• 인스턴스마다 별도의 cache
• 인스턴스 수가 많을 경우 cache가 선형적으로 증가

이 동작을 명확히 이해하지 않은 상태에서 적용하면, 메모리 사용량을 예측하기 어렵다.

5. 그럼 현재 내가 하고 있는 실무에서.. 사용하기 적절한가?

• DataLoader는 run당 하나만 생성된다
• 동일 path가 여러 번 사용될 가능성이 있다
• 로드 및 가공 비용이 크다
• 결과의 최신성 요구가 낮다

이 조건들은 lru_cache가 기대한 대로 동작하기에 충분한 근거를 제공한다. 이론적으론 맞을 지 몰라도 실제로 cache hit이 발생하는지 확인하지 않으면 원래의 의도와 달리 메모리만 소비할 수 있다.때문에 hit 비율을 확인해야 한다.

hits / (hits + misses)

이 값이 충분히 높다면, 해당 cache는 구조적으로 의미가 있다. 월요일에 출근 하자 마자 .. 다시 log 찍어보는걸로!_!

LSTM Autoencoder와 시퀀스 입력–출력 구조

1. 시퀀스 모델에서의 입력–출력 구조

순환 신경망(RNN) 및 LSTM 계열 모델은 입력과 출력이 시간 축을 따라 어떻게 대응되는가에 따라 여러 구조로 구분된다. 이러한 구분은 모델이 시계열 정보를 어떤 방식으로 요약하고, 언제 출력으로 전개하는지를 이해하는 데 중요한 기준이 된다.

아래 그림은 대표적인 다섯 가지 시퀀스 입력–출력 구조를 도식화한 것이다.

1.1 One-to-One 구조

하나의 입력이 하나의 출력으로 대응되는 구조이다. 시간적 의존성이 명시적으로 활용되지 않으며, 구조적으로는 feedforward 신경망과 동일하다. 시계열 문제에서는 제한적인 경우에만 사용된다.

대표적인 예시

• 특정 시점의 센서 벡터 → 해당 시점의 상태 값 예측
• 고정 길이 특징 벡터 → 하나의 회귀값 또는 클래스
• 시계열 데이터에서 시간 축을 제거하고, 통계 요약값만을 입력으로 사용하는 경우

1.2 One-to-Many 구조

하나의 입력으로부터 여러 시점의 출력을 생성하는 구조이다. 입력은 고정된 컨텍스트로 작용하며, 출력은 시간 축을 따라 순차적으로 생성된다.

대표적인 예시

• 이미지 하나 → 설명 문장 생성 (Image Captioning)
• 초기 상태 벡터 → 미래 시점의 시계열 시뮬레이션
• 단일 조건 벡터 → 제어 시퀀스 생성

1.3 Many-to-One 구조

여러 시점의 입력 시퀀스를 하나의 출력으로 요약하는 구조이다. 시계열 분류나 상태 판별과 같이, 시퀀스 전체에 대한 하나의 판단이 필요한 문제에 주로 사용된다.

대표적인 예시

• 일정 시간 구간의 센서 시계열 → 정상 / 이상 분류
• 문장 전체 → 감정 분류 결과
• 공정 로그 시퀀스 → 공정 상태 라벨

1.4 Many-to-Many 구조 (동기식)

입력 시퀀스와 출력 시퀀스가 동일한 길이를 가지며, 각 시점의 입력과 출력이 직접 대응되는 구조이다.

대표적인 예시

• 과거 시계열 → 같은 길이의 미래 시계열 예측
• 시계열 데이터 → 시점별 이상 점수 산출
• 문장 입력 → 각 단어에 대한 품사 태깅

1.5 Many-to-Many 구조 (비동기식, Encoder–Decoder)

입력 시퀀스를 모두 처리한 뒤, 별도의 출력 시퀀스를 생성하는 구조이다. 입력과 출력 시퀀스의 길이는 서로 다를 수 있으며, 일반적으로 Encoder–Decoder 구조 또는 sequence-to-sequence 구조라고 불린다.

대표적인 예시

• 문장 → 다른 언어의 문장 (기계 번역)
• 음성 신호 시퀀스 → 텍스트 시퀀스
• 시계열 전체 → 요약된 이벤트 시퀀스
• 시계열 → 동일한 시계열의 재구성 (LSTM Autoencoder)

LSTM Autoencoder는 이 구조를 사용하되, 출력 시퀀스를 새로운 목표 시퀀스가 아니라 입력 시퀀스 자체의 재구성으로 설정한다.

2. LSTM Autoencoder의 기본 개념

LSTM Autoencoder는 시계열 데이터를 입력으로 받아, 동일한 시계열을 다시 복원하도록 학습되는 비지도 학습 모델이다.

이 모델의 핵심 목적은 다음과 같이 정리할 수 있다.

시계열 전체를 고정 차원의 잠재 표현으로 압축한 뒤, 해당 표현만을 이용해 원래 시계열의 시간 구조를 재구성한다.

이를 위해 LSTM Autoencoder는 Encoder LSTM과 Decoder LSTM으로 구성된다.

3. Encoder–Decoder 구조

이 글에선 입력 시퀀스와 출력 시퀀스의 길이가 동일한 재구성(autoencoding) 설정을 가정한다.

3.1 Encoder LSTM

입력 시계열을 다음과 같이 정의한다.

$$ X = (x_1, x_2, \dots, x_T) $$

Encoder LSTM은 입력 시퀀스를 시간 순서대로 처리하며 hidden state와 cell state를 갱신한다.

• Cell state : 시계열 전반에 걸쳐 유지되는 long-term memory를 담당
  • 여러 시점을 관통하는 추세
  • 장기간 유지되어야 할 상태 정보
  • 급격한 변동에 쉽게 흔들리지 않는 정보
• Hidden state : 현재 lstm cell 시점에서의 output
  • 현재 시점의 입력, 장기 기억(cell state), 직전 hidden state의 요약 정보

$$ (h_t, c_t) = \mathrm{LSTM}{enc}(x_t, h{t-1}, c_{t-1}) $$

마지막 시점의 hidden state는 시계열 전체를 요약한 잠재 벡터로 사용된다.

$$ z = h_T $$

Cell state (c_T)를 잠재 표현으로 사용하는 변형도 존재하지만, 일반적으로는 hidden state (h_T)가 더 널리 사용된다.

3.2 Decoder LSTM

Decoder LSTM은 Encoder가 생성한 잠재 벡터 (z)를 초기 상태로 받아, 시간 순서에 따라 입력 시퀀스를 재구성하는 역할을 한다.

일반적으로 잠재 벡터 (z)는 Decoder LSTM의 초기 hidden state와 cell state로 주어진다.

$$ (\hat{h}_0, \hat{c}_0) = g(z) $$

이후 시점 (t)에서 Decoder LSTM의 상태는 다음과 같이 갱신된다.

$$ (\hat{h}t, \hat{c}_t) = \mathrm{LSTM}{dec}(\hat{x}{t-1}, \hat{h}{t-1}, \hat{c}_{t-1}) $$

각 시점의 출력은 hidden state로부터 계산된다.

$$ \hat{x}_t = f(\hat{h}_t) $$

여기서 (f(\cdot))는 선형 변환 혹은 출력 차원에 맞춘 비선형 함수이다.

4. 학습 목표 함수

LSTM Autoencoder는 입력 시계열과 출력 시계열 간의 차이를 최소화하도록 학습된다. 대표적인 손실 함수는 평균 제곱 오차(MSE)이다.

$$ \mathcal{L} = \sum_{t=1}^{T} | x_t - \hat{x}_t |^2 $$

이 손실 함수는 단순한 복사 문제처럼 보일 수 있으나, 다음과 같은 구조적 제약이 존재한다.

• Encoder는 전체 시계열을 하나의 고정 차원 벡터로 압축해야 한다.
• Decoder는 해당 벡터를 기반으로 시간적 구조를 복원해야 한다.

따라서 잠재 벡터 (z)에는 시계열의 전반적인 동역학 정보가 내재될 수밖에 없다.

5. Many-to-Many 구조와 LSTM Autoencoder의 해석

그림 X의 비동기식 many-to-many 구조는 LSTM Autoencoder를 이해하는 핵심 틀을 제공한다.

• 입력 시퀀스 전체 → Encoder
• 잠재 벡터 (z) → Decoder
• 출력 시퀀스 전체

LSTM Autoencoder는 이 구조를 그대로 사용하되, 출력 시퀀스를 새로운 목표 시퀀스가 아니라 입력 시퀀스 자체의 재구성으로 설정한다.

즉,

LSTM Autoencoder는 sequence-to-sequence 형태의 many-to-many 구조를 이용한 시계열 재구성 모델이다.

6. 이상 탐지 관점에서의 활용

이상 탐지 목적으로 사용되는 경우, LSTM Autoencoder는 일반적으로 정상 시계열 데이터만을 사용해 학습된다.

정상 데이터에 대해 학습된 모델은 정상적인 시간 패턴에 대해서는 낮은 재구성 오차를 보이는 반면, 비정상적인 패턴에 대해서는 높은 재구성 오차를 보인다.

시점별 재구성 오차는 다음과 같이 정의할 수 있다.

$$ e_t = | x_t - \hat{x}_t | $$

또는 시퀀스 단위의 재구성 오차:

$$ E = \sum_{t=1}^{T} e_t $$

이 오차를 기준으로 시계열의 정상 여부를 판단할 수 있다.

7. 코드

import torch.nn as nn


# Encoder
class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, dropout, seq_len):
        super().__init__()
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.seq_len = seq_len

        self.encoder_lstm = nn.LSTM(
            input_size=input_dim,
            hidden_size=hidden_dim,
            dropout=dropout,
            batch_first=True
        )

    def forward(self, input_seq):
        encoder_outputs, (h_n, c_n) = self.encoder_lstm(input_seq)

        # last hidden state -> latent representation
        latent = h_n.squeeze(0)                       # (B, H)
        latent_seq = latent.unsqueeze(1).repeat(1, input_seq.size(1), 1)

        return latent_seq, encoder_outputs


# Decoder
class Decoder(nn.Module):
    def __init__(self, output_dim, hidden_dim, dropout, seq_len, use_output_activation):
        super().__init__()
        self.output_dim = output_dim
        self.hidden_dim = hidden_dim
        self.seq_len = seq_len
        self.use_output_activation = use_output_activation

        self.decoder_lstm = nn.LSTM(
            input_size=hidden_dim,
            hidden_size=hidden_dim,
            dropout=dropout,
            batch_first=True
        )

        self.output_layer = nn.Linear(hidden_dim, output_dim)
        self.activation = nn.Sigmoid()

    def forward(self, latent_seq):
        decoder_outputs, (h_n, c_n) = self.decoder_lstm(latent_seq)
        reconstructed_seq = self.output_layer(decoder_outputs)

        if self.use_output_activation:
            reconstructed_seq = self.activation(reconstructed_seq)

        return reconstructed_seq, h_n


# LSTM AutoEncoder
class LSTMAutoEncoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, dropout, seq_len, use_output_activation=True):
        super().__init__()
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.seq_len = seq_len

        self.encoder = Encoder(
            input_dim=input_dim,
            hidden_dim=hidden_dim,
            dropout=dropout,
            seq_len=seq_len
        )

        self.decoder = Decoder(
            output_dim=input_dim,
            hidden_dim=hidden_dim,
            dropout=dropout,
            seq_len=seq_len,
            use_output_activation=use_output_activation
        )

    def forward(self, input_seq, return_latent=False, return_encoder_outputs=False):
        latent_seq, encoder_outputs = self.encoder(input_seq)
        reconstructed_seq, last_hidden = self.decoder(latent_seq)

        if return_latent:
            return reconstructed_seq, last_hidden
        elif return_encoder_outputs:
            return reconstructed_seq, encoder_outputs

        return reconstructed_seq

2. CNN–LSTM 모델

1. CNN–LSTM이 필요한 배경

시계열 데이터 $x_1, x_2, \dots, x_T$는 다음 두 가지 구조를 동시에 가진다.

1. 국소 패턴(Local pattern) 짧은 시간 구간에서 반복적으로 나타나는 파형, 주기, 급격한 변화 → 필터 기반의 국소 특징 추출에 유리

2. 장기 의존성(Temporal dependency) 과거의 상태가 현재의 해석에 영향을 미침 → 상태(state)를 누적하는 순환 구조가 필요

CNN–LSTM은 이 두 구조를 분리된 역할로 처리한다.

즉,

CNN은 “무엇이 일어났는지”를 요약하고, LSTM은 “그 일이 언제, 어떤 순서로 일어났는지”를 학습한다.

2. 전체 구조 개요

입력 시계열을 다음과 같이 표현한다.

$$ \mathbf{X} \in \mathbb{R}^{T \times D} $$

• $T$: 시계열 길이
• $D$: 채널 수 (센서 수, 변수 수)

CNN–LSTM의 처리 흐름은 다음과 같다.

$$ \mathbf{X} ;\xrightarrow{\text{CNN}}; \mathbf{F} ;\xrightarrow{\text{LSTM}}; \mathbf{H} ;\xrightarrow{\text{Output Layer}}; \hat{\mathbf{y}} $$

3. CNN 단계: 국소 패턴 추출

3.1 1D Convolution의 적용

시계열에서는 시간 축을 따라 1D Convolution을 적용한다.

$$ \mathbf{F}t^{(k)} = \sum{i=0}^{K-1} \mathbf{W}i^{(k)} \cdot \mathbf{X}{t+i} + b^{(k)} $$

• $K$: 커널 크기 (time window)
• $k$: 필터 인덱스
• $\mathbf{F}^{(k)}$: $k$번째 필터의 feature map

3.2 의미 해석

이 연산은 다음을 의미한다.

• 짧은 시간 구간에서의 패턴을 감지
• 위치가 달라도 동일한 패턴을 같은 특징으로 인식
• 노이즈에 비교적 강인

CNN의 출력은 다음과 같은 형태가 된다.

$$ \mathbf{F} \in \mathbb{R}^{T' \times C} $$

• $C$: CNN 필터 개수
• $T'$: padding/stride에 따라 줄어든 시간 길이

3.3 Pooling의 역할 (선택적)

Pooling이 사용될 경우,

• 미세한 시간 정렬 오차에 둔감
• 계산량 감소
• 그러나 시간 해상도 손실

→ LSTM과 결합 시에는 과도한 pooling은 피하는 경우가 많다

4. LSTM 단계: 시간적 의존성 학습

CNN 출력 $\mathbf{F}$를 LSTM의 입력 시퀀스로 사용한다.

$$ \mathbf{f}1, \mathbf{f}_2, \dots, \mathbf{f}{T'} $$

4.1 LSTM 내부 연산

각 시점 $t$에서 LSTM은 다음을 계산한다.

$$ \begin{aligned} \mathbf{i}t &= \sigma(W_i \mathbf{f}_t + U_i \mathbf{h}{t-1} + b_i) \end{aligned} $$ $$\begin{aligned} \mathbf{f}t &= \sigma(W_f \mathbf{f}_t + U_f \mathbf{h}{t-1} + b_f) \end{aligned} $$ $$\begin{aligned} \mathbf{o}t &= \sigma(W_o \mathbf{f}_t + U_o \mathbf{h}{t-1} + b_o) \end{aligned} $$ $$\begin{aligned} \tilde{\mathbf{c}}t &= \tanh(W_c \mathbf{f}_t + U_c \mathbf{h}{t-1} + b_c) \end{aligned} $$

$$ \begin{aligned} \mathbf{c}t &= \mathbf{f}_t \odot \mathbf{c}{t-1} \end{aligned} $$ $$ \begin{aligned} \mathbf{i}_t \odot \tilde{\mathbf{c}}_t
\mathbf{h}_t &= \mathbf{o}_t \odot \tanh(\mathbf{c}_t) \end{aligned} $$

4.2 CNN과 결합되었을 때의 의미

• LSTM은 원시 신호가 아니라 CNN이 요약한 고수준 특징 시퀀스를 처리
• 불필요한 단기 변동은 CNN에서 제거됨
• LSTM은 장기 흐름에 집중 가능

5. 출력 구조

문제 유형에 따라 출력 방식이 달라진다.

5.1 시계열 분류

• 마지막 hidden state 사용

$$ \hat{y} = \mathrm{softmax}(W \mathbf{h}_{T'} + b) $$

5.2 시계열 회귀 / 예측

• 마지막 또는 모든 시점의 hidden state 사용

$$ \hat{y}_t = W \mathbf{h}_t + b $$

5.3 이상 탐지 (Autoencoder 계열)

• LSTM Decoder를 추가하여 재구성 오차 사용

6. CNN–LSTM의 설계 의도 정리

CNN–LSTM은 다음 가정을 내포한다.

“의미 있는 단기 패턴이 먼저 존재하고, 그 패턴들의 시간적 조합이 전체 의미를 결정한다.”

7. 장점과 한계

7.1 장점

• 원시 시계열에서 수작업 feature engineering 감소
• LSTM 단독 사용 대비 학습 안정성 증가
• 다변량 센서 데이터에 적합

7.2 한계

• 구조가 비교적 무거움 (CNN + LSTM)
• 매우 긴 시계열에서는 여전히 비효율
• 전역 의존성 모델링에는 Transformer 대비 한계

8. 언제 CNN–LSTM을 사용하는가

다음 조건일 때 특히 효과적이다.

• 짧은 주기의 반복 패턴이 중요한 경우
• 센서 신호, 진동, 로그 시계열
• 이상 탐지, 상태 분류, 이벤트 인식

반대로,

• 장기 의존성이 매우 길거나
• 전역 패턴이 중요한 경우

→ TCN, Transformer 계열이 더 적합할 수 있다.

9. 코드

class CNNLSTM(nn.Module):
    def __init__(
        self,
        input_dim,        # D
        cnn_channels,     # C
        kernel_size,      # K
        lstm_hidden_dim,  # H
        lstm_layers,
        num_classes,
        dropout=0.0
    ):
        super().__init__()

        # -------------------------
        # 1. CNN (1D Convolution)
        # -------------------------
        self.conv1d = nn.Conv1d(
            in_channels=input_dim,
            out_channels=cnn_channels,
            kernel_size=kernel_size,
            padding=kernel_size // 2  # time length 유지
        )

        self.relu = nn.ReLU()

        # -------------------------
        # 2. LSTM
        # -------------------------
        self.lstm = nn.LSTM(
            input_size=cnn_channels,
            hidden_size=lstm_hidden_dim,
            num_layers=lstm_layers,
            batch_first=True,
            dropout=dropout if lstm_layers > 1 else 0.0
        )

        # -------------------------
        # 3. Output layer
        # -------------------------
        self.fc = nn.Linear(lstm_hidden_dim, num_classes)

    def forward(self, x):
        """
        x: (B, T, D)
        """

        # -------------------------
        # CNN expects (B, D, T)
        # -------------------------
        x = x.permute(0, 2, 1)

        # (B, C, T)
        x = self.conv1d(x)
        x = self.relu(x)

        # -------------------------
        # LSTM expects (B, T, C)
        # -------------------------
        x = x.permute(0, 2, 1)

        # x: (B, T, C)
        lstm_out, (h_n, c_n) = self.lstm(x)

        # -------------------------
        # 마지막 시점 hidden state
        # -------------------------
        h_last = lstm_out[:, -1, :]   # (B, H)

        # -------------------------
        # Output
        # -------------------------
        out = self.fc(h_last)         # (B, num_classes)

        return out

• pytorch conv1d 입력 형식 : (batch, channels, length)
• 시계열 데이터 : (batch, time, features) → 시간 축을 length로 보기 위해 permute가 필수

1. 오버피팅이란 무엇인가

오버피팅(overfitting)이란, 학습된 모델이 훈련 데이터(training data) 에는 매우 높은 성능을 보이지만, 학습에 사용되지 않은 시험 데이터(test data) 나 실제 환경의 새로운 데이터에 대해서는 성능이 급격히 저하되는 현상을 의미한다. 이는 모델이 데이터에 존재하는 일반적인 패턴을 학습한 것이 아니라, 훈련 데이터에만 존재하는 우연적 노이즈나 특이한 패턴까지 과도하게 학습했기 때문에 발생한다.

기계학습과 딥러닝의 궁극적인 목표는 훈련 데이터 자체를 잘 맞히는 것이 아니라, 보지 못한 데이터에 대해서도 일관되게 좋은 예측을 수행하는 범용 성능(generalization performance) 을 확보하는 것이다. 따라서 오버피팅은 실무 관점에서도 반드시 해결해야 할 핵심 문제이다.

2. 오버피팅이 발생하는 주요 원인

오버피팅은 다음과 같은 조건에서 특히 빈번하게 발생한다.

1. 훈련 데이터의 양이 부족한 경우 데이터가 충분하지 않으면, 모델은 데이터의 통계적 특성을 안정적으로 학습하기 어렵다. 특히 딥러닝 모델처럼 파라미터 수가 많은 경우, 소량의 데이터는 오버피팅을 거의 필연적으로 유발한다.

2. 모델의 복잡도가 데이터에 비해 지나치게 높은 경우 층의 수가 많거나, 각 층의 뉴런 수가 매우 큰 모델은 높은 표현력을 갖는다. 표현력이 높다는 것은 복잡한 함수 형태를 근사할 수 있다는 장점이 있지만, 동시에 훈련 데이터에 과도하게 맞춰질 위험이 커진다.

3. 학습을 지나치게 오래 수행한 경우 초기에는 훈련 데이터와 검증 데이터 모두 성능이 향상되지만, 일정 시점 이후에는 검증 성능이 오히려 하락하는 경우가 많다. 이는 모델이 훈련 데이터에 과적합되기 시작했음을 의미한다.

3. 오버피팅의 전형적인 관찰 패턴

오버피팅이 발생하면 다음과 같은 특징적인 현상이 나타난다.

• 훈련 정확도는 에폭(epoch)이 증가함에 따라 지속적으로 상승
• 검증(validation)/시험(test) 정확도는 어느 시점 이후 정체되거나 하락
• 훈련 손실(loss)은 감소하지만, 검증 손실은 증가

이러한 패턴을 통해 오버피팅 여부를 시각적으로 판단할 수 있다.

2장. 가중치 감쇠(Weight Decay)

1. 가중치 감쇠의 직관적 이해

딥러닝 모델에서 가중치(weight)가 커질수록 모델은 입력 데이터의 작은 변화에도 매우 민감하게 반응하게 된다. 이는 모델의 표현력을 증가시키는 효과가 있지만, 동시에 데이터의 노이즈까지 학습하게 만들어 오버피팅을 유발한다.

가중치 감쇠(weight decay) 는 이러한 문제를 완화하기 위해, 학습 과정에서 가중치의 크기가 커지는 것을 억제하는 정규화(regularization) 기법이다.

2. 수식적 정의

가중치 감쇠는 손실 함수(loss function)에 가중치의 L2 노름(norm) 제곱을 패널티 항으로 추가하는 방식으로 구현된다.

• 기존 손실 함수: $$L$$

• 가중치 감쇠가 적용된 손실 함수: $$L' = L + λ \sum_i w_i^2$$

여기서 λ(람다)는 정규화 계수(regularization strength) 로, 가중치 크기에 대한 패널티의 강도를 조절한다.

(1) 가중치가 커질수록 더 강한 패널티

과적합의 핵심 원인은 보통

일부 가중치가 과도하게 커지면서 특정 샘플에만 맞춘 결정 경계를 만드는 것

** 결정 경계란 아주 미세한 입력 차이까지 구분하려는 경계이다. ** 일부 가중치가 과도하게 커진다는 것은, 입력 공간의 특정 방향에 대해 모델의 출력이 지나치게 민감해졌음을 의미한다. 이러한 경우 결정 경계는 소수의 샘플, 특히 노이즈나 이상치가 포함된 샘플을 정확히 분류하기 위해 국소적으로 급격하게 변형된다. 그 결과 모델은 데이터 분포 전반에 공통적으로 나타나는 구조를 학습하기보다는, 개별 학습 샘플의 우연한 특성에 맞춰진 결정 규칙을 형성하게 된다. ** 하여, 전체 데이터 분포에는 중요하지 않은 방향에 매우 큰 가중치가 할당될 수 있다.

그래서 정규화 항은 다음 성질을 가져야 한다.

• (w = 0) 근처에서는 영향이 작고
• (|w|)가 커질수록 패널티가 빠르게 증가 ** 특정 가중치를 과도하게 키우는 것을 방지

즉,

• 작은 가중치: 거의 벌점 없음
• 큰 가중치: 제곱으로 급격히 증가

(2) 미분 가능하고, 최적화가 쉬워야 한다

신경망은 경사 하강법으로 학습한다. 따라서 패널티 항은 반드시:

• 모든 점에서 미분 가능
• gradient가 안정적이어야 한다

L2 제곱의 미분은:

$$\frac{\partial}{\partial w_i} \left( \frac{\lambda}{2} w_i^2 \right) = \lambda w_i$$

이 결과가 중요한 이유는:

• gradient가 선형
• 갑작스럽게 튀지 않음
• 학습이 안정적

(반면 L1은 (w=0)에서 미분 불연속 → 다른 성질을 만든다)

3. 정규화가 포함된 손실 함수

원래 손실 함수 (L(w))에 L2 패널티를 추가하면:

$$\tilde{L}(w) = L(w) + \frac{\lambda}{2} |w|_2^2$$

이걸 그대로 미분하면

$$\frac{\partial \tilde{L}}{\partial w} = \frac{\partial L}{\partial w}* \lambda w$$

업데이트 식은 다음과 같다.

$$w \leftarrow w - \eta \left( \frac{\partial L}{\partial w} + \lambda w \right)$$

이를 분해하면:

$$w \leftarrow (1 - \eta \lambda) w ;-; \eta \frac{\partial L}{\partial w}$$

• $$- \eta \frac{\partial L}{\partial w}$$ → 데이터에 맞추려는 힘

• $$(1 - \eta \lambda) w$$ → 가중치를 원점(0)으로 끌어당기는 힘

즉, L2 정규화는매 step마다 모든 가중치를 조금씩 0 방향으로 수축(shrink) 시킨다

그래서 이름이 Weight Decay(가중치 감쇠) 다.

• (w)가 크면 → 과적합 가능성 큼 → 강하게 줄여야 함
• (w)가 작으면 → 이미 단순한 모델 → 거의 건드리지 않음

4. 학습 과정에서의 영향

경사 하강법(gradient descent)을 적용하면, 각 가중치는 다음과 같이 업데이트된다.

• 기존 업데이트: $$w ← w − η (∂L/∂w)$$

• 가중치 감쇠 적용 후: $$w ← w − η (∂L/∂w + λw)$$

즉, 가중치는 손실 함수의 기울기뿐 아니라 자신의 크기에 비례하여 추가적으로 감소하는 방향으로 업데이트된다.

5. 효과와 한계

• 장점:

  • 모델이 지나치게 복잡해지는 것을 방지
  • 구현이 단순하고 계산 비용이 낮음

• 한계:

  • λ 값이 너무 크면 과소적합(underfitting) 발생
  • 데이터가 매우 복잡한 경우 단독으로는 충분하지 않을 수 있음

3장. 드롭아웃(Dropout)

1. 드롭아웃의 기본 아이디어

드롭아웃(dropout)은 학습 단계에서 신경망의 일부 뉴런을 무작위로 비활성화하는 기법이다. 각 미니배치(mini-batch)가 입력될 때마다, 뉴런은 확률 p로만 활성화되고 나머지는 임시로 제거된다.

이는 다음과 같은 효과를 갖는다.

• 매 학습 단계마다 서로 다른 구조의 신경망을 학습하는 효과
• 특정 뉴런이나 경로에 대한 과도한 의존 방지
• 앙상블(ensemble) 학습과 유사한 정규화 효과

2. training 과 testing 단계의 차이

• 학습 단계(training) 일부 뉴런만 활성화된 축소된 네트워크로 학습 수행 forward pass에서 일부 뉴런의 출력이 0이 됨 뉴런들의 결과를 평균내기 때문에, 출력 크기 자체가 줄어듬 수식적으로는, 뉴런 수는 그대로이며, 각 뉴런의 출력의 기댓값이 줄어든 것임

• 시험 단계(testing) 모든 뉴런을 사용하되, 출력값에 활성화 확률 p를 곱하여 스케일을 보정

이는 학습 시 평균적으로 사용된 활성화 크기와 시험 시 활성화 크기를 일치시키기 위함이다.

3. 직관적 해석

드롭아웃은 각 뉴런이 "언제든지 제거될 수 있다"는 가정하에 학습되도록 강제한다. 그 결과, 모델은 특정 뉴런에 의존하지 않고 보다 분산된 표현(distributed representation) 을 학습하게 된다. 즉, 어떤 뉴런도 항상 켜져있다(0이 아니다)고 가정할 수 없고, 다음 step에서도 반드시 사용될 것이라고 기대할 수 없다는 것을 의미한다. 이로 인하여, drop out을 적용한 최적화는 "일부 뉴런이 없어져도, 전체 출력이 크게 변하지 않는 방향"으로 유도된다. 이는 모델이 자연스럽게 하나의 의미(특징)를 여러 뉴런이 나눠서 표현하게 하여, 단일 뉴런 하나에만 강하게 인코딩 되지 않고 여러 뉴런의 활성화 조합으로 표현되어 의미 정보가 여러 뉴런에 분산되어 저장된다.

4. 장단점

• 장점:

  • 강력한 오버피팅 억제 효과
  • 다양한 문제에서 안정적인 성능 향상

• 단점:

  • 학습 속도 저하 이는 매번 구조가 조금씩 바뀌는 모델을 학습하기 때문에, gradient의 분산이 커지고 손실 곡선이 덜 매끄러워져, 수렴이 느려진다.
  • 배치 정규화와 함께 사용할 경우 조합에 주의 필요 배치 정규화는 다음을 가정한다. "현재 레이어의 활성화 분포는, 미니 배치 기준으로 비교적 안정적인 추정이 가능" 배치 정규화는 학습 중에, 배치의 평균과 분산을 계산하여 이 통계 값을 이동 평균으로 누적하고 테스트시에는 이 값을 사용한다. 하지만, 배치 정규화 앞에 드롭아웃을 두면, 활성화가 랜덤으로 0이되어, 배치 평균과 분산이 매 step마다 크게 흔들리고, 드롭아웃 노이즈가 섞인 분포를 학습하여 테스트 시 분포와 실제 분포가 달라지게 되는 문제점이 있다 만약 배치 정규화 뒤에 드롭아웃을 두면 배치 정규화의 작업을 드롭아웃이 다시 랜덤하게 꺠뜨리기때문에, 배치 정규화가 만든 안정성이 일부 상쇄된다. 이 경우 배치 정규화의 효고와 드롭아웃의 효과가 중복되거나 충돌될 수 있다.

4장. 검증 데이터와 하이퍼파라미터 최적화

1. 하이퍼파라미터란 무엇인가

하이퍼파라미터(hyper-parameter)는 오차 역전파로 학습되지 않고, 사용자가 사전에 설정해야 하는 모든 파라미터를 의미한다.

대표적인 예시는 다음과 같다.

• 학습률(learning rate)
• 배치 크기(batch size)
• 은닉층의 수와 각 층의 뉴런 수
• 가중치 감쇠 계수 λ
• 드롭아웃 비율
• 학습 epoch 수

2. 데이터 분할의 원칙

• 훈련 데이터: 모델 파라미터 학습
• 검증 데이터: 하이퍼파라미터 선택
• 시험 데이터: 최종 성능 평가

시험 데이터를 하이퍼파라미터 조정에 사용하면, 모델이 시험 데이터에 오버피팅되므로 절대 사용해서는 안 된다.

3. 하이퍼파라미터 탐색 절차

1. 탐색할 하이퍼파라미터 범위 설정
2. 범위 내에서 무작위 또는 체계적으로 샘플링
3. 각 설정에 대해 짧은 학습 수행
4. 검증 성능을 기준으로 범위 축소 및 반복

5장. Early Stopping

1. Early Stopping의 개념

Early stopping은 학습을 충분히 오래 수행하지 않고, 검증 성능이 더 이상 개선되지 않는 시점에서 학습을 중단하는 기법이다.

이는 학습 자체를 정규화로 활용하는 방법이라고 볼 수 있다.

2. 장점

• 추가적인 계산 비용 없이 오버피팅 억제
• 매우 깊은 모델에서도 실용적인 적용 가능

6장. 배치 정규화(Batch Normalization)

1. 깊은 신경망 학습의 어려움

깊은 신경망에서는 이전 계층의 가중치가 업데이트될 때마다, 다음 계층으로 전달되는 입력 분포가 계속 변한다. 이를 내부 공변량 변화(internal covariate shift) 라고 하며, 학습을 불안정하고 느리게 만드는 주요 원인이다.

2. 배치 정규화의 핵심 아이디어

배치 정규화는 각 계층의 입력을 미니배치 단위로 정규화하여 평균 0, 분산 1에 가깝게 만드는 기법이다.

절차는 다음과 같다.

1. 미니배치 평균 계산
2. 미니배치 분산 계산
3. 정규화 수행
4. 학습 가능한 파라미터 γ, β로 스케일 및 이동

이를 통해 표현력 감소 문제를 해결한다.

3. training 과 testing 단계의 처리 방식

• 학습 단계: 미니배치 통계량 사용
• 시험 단계: 학습 중 누적한 이동 평균(mean, variance) 사용

이를 통해 입력이 하나씩 들어오는 상황에서도 안정적인 정규화를 수행할 수 있다.

4. 배치 정규화의 효과

• 학습 속도 대폭 향상
• 초기 가중치에 대한 민감도 감소
• 오버피팅 완화 효과

5. 한계와 확장 기법

배치 크기가 매우 작을 경우, 통계량이 불안정해진다. 이를 보완하기 위해 다음과 같은 기법들이 제안되었다.

• Layer Normalization
• Group Normalization
• Instance Normalization

1.1 학습의 수학적 정의

딥러닝 모델은 다음과 같은 최적화 문제로 정의된다.

$$ \theta^* = \arg\min_\theta ; \mathbb{E}_{(x,y)\sim \mathcal{D}} \left[ L(f(x;\theta), y) \right] $$

여기서:

• ( $$\theta$$ ): 모델의 모든 파라미터 집합 (가중치, 바이어스)
• ( $$f(x;\theta)$$ ): 신경망이 정의하는 비선형 함수
• ( $$L(\cdot)$$ ): 손실 함수
• ( $$\mathcal{D}$$ ): 데이터 분포

Convex(볼록) 함수는 하나의 완전한 최소점만 있지만, 딥러닝 손실 함수는 구불구불한 산과 계곡이 많아 여러 최소점이 존재합니다. 그래서 최적화가 훨씬 어렵다. 실제 학습은 비볼록(non-convex) 손실 공간에서의 수치적 최적화 과정이며, 이때 초기화와 최적화 알고리즘은 다음을 결정한다.

• 어떤 영역에서 탐색을 시작하는가 (initial point)
• 탐색 경로가 얼마나 안정적인가 (conditioning)
• 국소 최소/안장점(saddle point)을 얼마나 잘 탈출하는가

1.2 초기화와 최적화의 역할 분리

초기화는 학습이 가능한 상태를 만들고, 최적화는 그 상태에서 얼마나 잘 학습할 수 있는지를 결정한다.

2. 가중치 초기화 (Weight Initialization)

2.1 초기화 실패가 야기하는 구조적 문제

(1) Symmetry Breaking 실패

만약 각 뉴런의 가중치가 전부 같으면, 입력이 아무리 다르더라도 뉴런의 출력이 같아지고 결국 학습이 분쇄되지 않는다. 모든 가중치를 0으로 초기화할 경우, 같은 층의 모든 뉴런은 다음을 공유한다.

• 동일한 입력
• 동일한 출력
• 동일한 gradient

결과적으로: $$ \frac{\partial L}{\partial W_1} = \frac{\partial L}{\partial W_2} = \cdots $$

→ 학습이 진행되어도 뉴런 간 역할 분화가 발생하지 않는다. 이는 표현력 붕괴(representational collapse)로 이어진다.

(2) Gradient Vanishing / Exploding의 근본 원인

은닉층 ( l )의 선형 변환을 다음과 같이 두자.

$$ z^{(l)} = W^{(l)} a^{(l-1)} $$

만약:

• ( $$\text{Var}(W^{(l)}) \gg 1$$ ) → 분산 폭주
• ( $$\text{Var}(W^{(l)}) \ll 1$$ ) → 분산 수축

이면, 깊이에 따라 다음 현상이 반복적으로 누적된다.

$$ \text{Var}(z^{(l)}) = n \cdot \text{Var}(W^{(l)}) \cdot \text{Var}(a^{(l-1)}) $$

즉, 초기 분산 선택은 깊이 방향으로의 분산 전파를 제어하는 문제다.

활성화 함수의 출력이 특정 범위에 집중되면, 역전파될 때 그 기울기가 점점 작아져 신호가 사라지기도(=vanishing), 너무 커지기도(=exploding) 한다.

2.2 분산 보존 관점에서의 초기화 원리

이상적인 초기화 조건은 다음 두 가지를 동시에 만족해야 한다.

1. Forward pass $$ \text{Var}(a^{(l)}) \approx \text{Var}(a^{(l-1)}) $$

2. Backward pass $$ \text{Var}\left(\frac{\partial L}{\partial a^{(l)}}\right) \approx \text{Var}\left(\frac{\partial L}{\partial a^{(l-1)}}\right) $$

이는 초기화가 단순한 “시작값 설정”이 아니라, 네트워크 전체를 관통하는 신호 전달 시스템의 스케일링 문제임을 의미한다.

2.3 Xavier Initialization (Glorot Initialization)

(1) 이론적 가정

• 입력 ( $$x_i$$ )는 평균 0, 분산 ( $$\sigma^2$$ )
• 가중치 ( $$W_i$$ )는 독립이고 평균 0
• 활성화 함수는 선형 또는 약한 비선형 (sigmoid, tanh)

이때, $$ \text{Var}(z) = n \cdot \text{Var}(W) \cdot \text{Var}(x) $$

이를 입력 분산과 동일하게 유지하려면: $$ \text{Var}(W) = \frac{1}{n} $$

(2) 수식적 정의

• 정규분포: $$ W \sim \mathcal{N}\left(0, \frac{1}{n}\right) $$

• 균등분포: $$ W \sim U\left(-\sqrt{\frac{6}{n}}, \sqrt{\frac{6}{n}}\right) $$

(3) 한계

• Sigmoid/Tanh의 포화 영역 문제는 완화하지만 제거하지는 못함
• ReLU 계열에서는 활성화 분산이 절반으로 감소

→ ReLU 기반 네트워크에서는 분산 손실 누적 발생

2.4 He Initialization

(1) ReLU 활성화의 통계적 특성

ReLU는 다음과 같이 정의된다. $$ \text{ReLU}(x) = \max(0, x) $$

입력이 대칭 분포일 경우:

• 출력의 약 50%가 0
• 분산이 약 절반으로 감소

이를 보정하기 위해: $$ \text{Var}(W) = \frac{2}{n} $$

(2) 정의

$$ W \sim \mathcal{N}\left(0, \frac{2}{n}\right) $$

(3) 효과

• 깊은 ReLU 네트워크에서 학습 안정성 확보
• BatchNorm 없이도 초기 학습 가능

2.5 초기화 방법의 선택 기준

3. 최적화 (Optimization)

3.1 경사하강법의 기하학적 해석

경사하강법은 다음을 반복한다.

$$ W_{t+1} = W_t - \eta \nabla L(W_t) $$

이는:

• 손실 함수의 1차 테일러 근사에서
• 가장 빠르게 감소하는 방향(negative gradient)을 따라 이동

한다는 의미다.

3.2 학습률의 역할

학습률(learning rate, ($$\eta$$))은 경사 하강법에서 파라미터가 한 번의 업데이트에서 얼마나 이동할지를 결정하는 스케일 계수이다. 기본적인 파라미터 업데이트 식은 다음과 같다.

$$\theta_{t+1} = \theta_t - \eta \nabla_\theta L(\theta_t)$$

여기서 gradient ($$\nabla_\theta L$$)는 손실을 가장 빠르게 감소시키는 방향을 제공하고, 학습률은 이 방향을 실제 파라미터 변화량으로 변환하는 크기를 결정한다.

손실 지형 관점에서의 학습률

손실 함수는 파라미터 공간에서 곡률(curvature)이 서로 다른 지형을 가진다. 학습률은 이러한 지형에 대해 다음과 같은 가정을 암묵적으로 포함한다.

현재 위치에서의 손실 지형은 이 정도 이동을 허용할 만큼 완만하다.

학습률이 이 가정과 맞지 않을 경우, 최적화는 불안정해진다.

학습률이 너무 큰 경우

학습률이 과도하게 크면 한 번의 업데이트가 최소점을 넘어가게 된다. 이로 인해 손실이 진동하거나 증가하며, 학습이 발산할 수 있다. 이는 손실 지형의 곡률에 비해 이동량이 지나치게 큰 경우에 발생한다.

학습률이 너무 작은 경우

학습률이 지나치게 작으면 파라미터가 매우 느리게 변화한다. 손실은 감소하지만, 평탄한 영역에서는 실질적인 학습이 거의 진행되지 않는다. 이 경우 이론적으로는 수렴 가능하더라도 실용적인 학습이 어렵다.

초기화 및 최적화와의 관계

학습률은 모델의 초기화 및 손실 지형의 conditioning과 밀접한 관련이 있다. 적절한 초기화는 파라미터 전반에 걸쳐 gradient의 스케일을 균형 있게 만들어, 하나의 학습률로 안정적인 학습이 가능하도록 한다.

반대로 초기화가 부적절하면, 일부 파라미터는 과도하게 업데이트되고 다른 일부는 거의 업데이트되지 않아 학습률 선택이 매우 어려워진다.

Local Minima (국소 최소점)

손실 함수 $$L(θ)$$를 파라미터 𝜃 에 대해 최적화할 때, local minima(국소 최소점)란 다음 조건을 만족하는 지점을 의미한다.

어떤 작은 이웃 범위 내에서는 손실이 최소이지만, 전체 파라미터 공간에서의 최소값(global minimum)는 아닌 지점

즉, 주변으로는 더 낮은 방향이 없지만, 멀리 떨어진 곳에는 더 낮은 손실값이 존재할 수 있다.

Local minima와 Global minima의 차이

Global minimum: 손실 함수 전체에서 가장 작은 값 Local minimum: 국소 영역에서만 가장 작은 값

딥러닝에서의 최적화는 일반적으로 global minimum을 보장하지 않으며, 실제로는 local minimum 또는 그 근방에서 수렴하는 경우가 많다.

딥러닝에서 local minima의 실제 영향

고전적인 비선형 최적화 문제와 달리, 고차원 딥러닝 모델에서는 다음과 같은 특성이 있다.

• 파라미터 차원이 매우 큼
• 동일한 성능을 갖는 최소점이 다수 존재
• 성능이 크게 나쁘지 않은 local minimum이 많음

이로 인해 딥러닝에서는 local minimum 자체가 치명적인 문제인 경우는 드물다 실제 학습 성능을 크게 저해하는 요인은 local minimum보다 saddle point(안장점) 인 경우가 많다.

학습률 및 초기화와의 관계

학습률과 초기화는 어떤 local minimum으로 수렴하는지를 결정하는 중요한 요소이다.

초기화: 최적화가 시작되는 위치를 결정 학습률: 국소 지형을 탈출할 수 있는 이동 크기를 결정 학습률이 너무 작으면: 얕은 local minimum이나 평탄한 영역에 쉽게 머무름 학습률이 적절하면: 얕은 local minimum을 지나쳐 더 낮은 손실 영역으로 이동 가능

4. 확률적 경사하강법 (Stochastic Gradient Descent, SGD)

딥러닝 최적화 기법의 역사는 모두 SGD로부터 시작된다. SGD는 가장 단순한 형태의 최적화 방법이지만, 이후 등장하는 Momentum, AdaGrad, RMSProp, Adam 등 모든 기법은 SGD가 가진 구조적 한계를 어떻게 극복할 것인가라는 문제의식에서 출발했다.

따라서 SGD는 단순한 “기본 방법”이 아니라, 최적화 기법 진화의 기준점(reference) 이다.

4.1 경사하강법의 기본 원리

최적화의 목적은 손실 함수 ( L(W) )를 최소화하는 파라미터 ( W )를 찾는 것이다. 경사하강법은 현재 위치에서의 기울기(gradient)를 이용해 손실이 가장 빠르게 감소하는 방향으로 파라미터를 갱신한다.

$$W_{t+1} = W_t - \eta \nabla L(W_t) $$ 여기서

• ( $$\eta$$ ) : 학습률(learning rate)
• ( $$\nabla L(W_t)$$ ) : 손실 함수의 기울기

이 업데이트 식은 손실 함수를 현재 지점에서 1차 테일러 근사로 해석했을 때, 손실을 가장 빠르게 감소시키는 방향이 gradient의 반대 방향이라는 사실에 기반한다.

4.2 Batch, Stochastic, Mini-batch Gradient Descent

이론적으로는 전체 데이터에 대한 정확한 gradient를 계산하는 것이 이상적이다. 그러나 딥러닝에서는 데이터 수가 매우 크기 때문에, 다음과 같은 근사 방식이 사용된다.

• Batch Gradient Descent

$$\nabla L(W) = \frac{1}{N} \sum_{i=1}^{N} \nabla L_i(W) $$ 전체 데이터 (N)개를 사용하므로 안정적이지만, 계산 비용이 매우 크다.

• Stochastic Gradient Descent (SGD)

$$\nabla L(W) \approx \nabla L_i(W) $$ 데이터 한 개로 gradient를 근사한다. 계산은 빠르지만, 업데이트의 분산이 크다.

• Mini-batch Gradient Descent

$$\nabla L(W) \approx \frac{1}{M} \sum_{i=1}^{M} \nabla L_i(W) $$ 계산 효율과 안정성 사이의 균형을 제공한다.

4.3 딥러닝 손실 함수의 기하적 특성

SGD의 한계를 이해하려면 딥러닝 손실 함수의 구조를 이해해야 한다.

딥러닝 손실 함수는 일반적으로 다음과 같은 특성을 가진다.

• 고차원 파라미터 공간
• Saddle point가 지역 최소점보다 훨씬 많음
• 방향마다 기울기 크기가 크게 다른 비등방성(non-isotropic) 구조

이러한 손실 지형은 SGD에 매우 불리하다.

4.4 SGD의 구조적 한계

(1) 지그재그 현상

손실 함수가 좁고 긴 계곡 형태일 경우, 한 방향에서는 gradient가 크고 다른 방향에서는 매우 작다. SGD는 큰 gradient 방향으로 과도하게 이동하고, 결과적으로 다음과 같은 비효율적인 경로를 따른다.

• 진동(oscillation)
• 불필요한 이동 거리 증가

(2) 느린 수렴

완만한 방향의 gradient는 매우 작기 때문에, 해당 방향으로의 이동은 극도로 느려진다. 이는 학습 초반뿐 아니라, 최소점 근처에서도 수렴 속도를 크게 저하시킨다.

(3) 전역 학습률의 한계

SGD는 모든 파라미터에 동일한 학습률 ( $$\eta$$ )를 적용한다. 그러나 실제로는:

• 어떤 파라미터는 큰 업데이트가 필요
• 어떤 파라미터는 매우 작은 업데이트가 필요

이로 인해 다음과 같은 딜레마가 발생한다.

• ( $$\eta$$ )가 크면: 발산 위험
• ( $$\eta$$ )가 작으면: 학습 속도 저하

SGD의 한계는 요약하면 다음 두 가지다.

1. 방향 정보가 현재 gradient에만 의존
2. 파라미터별 스케일 차이를 전혀 반영하지 못함

모던 최적화 기법들은 SGD가 가진 진동, 느린 수렴 문제를 보완하기 위해 등장했다. 이 문제를 해결하기 위한 첫 번째 시도가 바로 Momentum, 즉 과거 gradient의 누적이다.

5. Momentum

SGD의 가장 큰 문제는 현재 순간의 gradient에만 의존한다는 점이다. Momentum은 이 한계를 인식하고, 최적화 과정에 시간적 누적 정보(time history) 를 처음으로 도입한 방법이다.

즉, Momentum은 단순한 “속도 트릭”이 아니라, gradient의 1차 모멘트(평균 방향)를 추정하려는 시도로 이해할 수 있다.

5.1 왜 Momentum이 필요한가

SGD는 다음과 같은 구조적 문제를 가진다.

1. 비등방 손실 지형에서 지그재그 이동
2. 완만한 방향으로의 매우 느린 수렴
3. gradient 노이즈에 민감한 업데이트

이 문제들은 모두 gradient의 방향성이 불안정하다는 점에서 비롯된다. Momentum은 이 문제를 “과거의 gradient를 기억하자”는 발상으로 해결하고자 한다.

5.2 Momentum의 핵심 아이디어

Momentum은 현재 gradient뿐만 아니라, 과거 gradient의 누적 방향을 함께 고려한다.

이를 위해 새로운 변수인 속도(velocity) 를 도입한다.

$$\begin{aligned} v_t &= \alpha v_{t-1} - \eta \nabla L(W_t)
\end{aligned} $$ $$\begin{aligned} W_{t+1} &= W_t + v_t \end{aligned} $$ 여기서

• ( $$v_t$$ ): 누적된 이동 방향 (velocity)
• ( $$\alpha \in [0,1)$$ ): 관성 계수 (보통 0.9)

5.3 수식적 해석

Momentum 업데이트를 전개해 보면 다음과 같다.

$$v_t = -\eta \sum_{k=0}^{t} \alpha^{t-k} \nabla L(W_k) $$ 즉, Momentum은 과거 gradient들의 지수 이동 평균(EMA) 을 사용한다.

• 최근 gradient일수록 더 큰 가중치
• 오래된 gradient는 점점 영향 감소

이 관점에서 보면 Momentum은 다음을 수행한다.

“현재 gradient의 잡음을 줄이고, 일관된 하강 방향을 추정한다.”

5.4 기하학적 관점에서의 효과

Momentum은 손실 지형에서 다음과 같은 효과를 만든다.

• 진동이 심한 방향 → 상쇄됨
• 일관된 방향 → 가속됨

즉,

• 좁고 긴 계곡에서는 중심 방향으로 빠르게 이동
• 지그재그 경로가 완화됨

이는 SGD가 갖던 비효율적인 경로 문제를 크게 개선한다.

5.5 Momentum의 한계

Momentum은 분명한 진전이지만, 여전히 중요한 한계를 가진다.

(1) 현재 위치에서의 gradient만 사용

Momentum은 이동 방향을 누적하지만, gradient 계산 자체는 항상 현재 위치에서 수행된다. 이로 인해 다음 문제가 발생한다.

• 관성으로 인해 최소점을 지나쳐 버림 (overshooting)
• 최적점 근처에서 불안정한 진동

(2) 학습률 문제는 여전히 해결되지 않음

• 모든 파라미터에 동일한 ( $$\eta$$ ) 적용
• 파라미터별 스케일 차이 미반영

즉, Momentum은 방향성 문제는 완화했지만, “지금 어디로 가고 있는가”를 미리 고려하지는 못한다.

Momentum의 한계는 다음 질문으로 이어진다.

“관성으로 이동할 것을 알고 있다면, 그 위치에서의 gradient를 미리 계산할 수는 없을까?”

이 질문에 대한 해답이 바로 Nesterov Accelerated Gradient (NAG) 이다.

6. Nesterov Accelerated Gradient (NAG)

Momentum은 SGD의 지그재그 문제를 효과적으로 완화했지만, 새로운 한계를 드러냈다. 바로 관성으로 인해 최소점을 지나쳐 버리는 현상(overshooting) 이다.

Nesterov Accelerated Gradient(NAG)는 이 문제를 다음과 같은 질문으로 재정의한다.

“어차피 관성으로 이동할 예정이라면, 그 이동한 위치에서의 gradient를 미리 계산하면 어떨까?”

이 질문이 Nesterov의 출발점이다.

6.1 Momentum의 근본적 한계 재해석

Momentum 업데이트는 다음과 같다.

$$\begin{aligned} v_t &= \alpha v_{t-1} - \eta \nabla L(W_t)
\end{aligned} $$

$$\begin{aligned} W_{t+1} &= W_t + v_t \end{aligned} $$ 이 식의 문제는 명확하다.

• 실제로는 ( $$W_t$$ )에서 gradient를 계산하지만
• 파라미터는 ( $$W_t + \alpha v_{t-1}$$ ) 방향으로 이동하게 됨

즉, gradient를 계산한 위치와 실제 이동 방향이 불일치한다.

이 불일치는 다음 현상을 유발한다.

• 최소점 근처에서 과도한 이동
• 불필요한 진동
• 수렴 지연

6.2 Nesterov의 핵심 아이디어: Look-ahead Gradient

Nesterov는 gradient를 계산하기 전에 한 발 앞서 이동한다.

$$W't = W_t + \alpha v{t-1} $$ 그리고 이 미래 위치에서 gradient를 계산한다.

$$\begin{aligned} v_t &= \alpha v_{t-1} - \eta \nabla L(W't)
\end{aligned} $$ $$\begin{aligned} W{t+1} &= W_t + v_t \end{aligned} $$ 즉,

“이동한 다음에 어떤 경사가 기다리고 있는지를 먼저 본다.”

이것이 Nesterov의 본질이다.

6.3 수식적 관점: 왜 overshooting이 줄어드는가

Nesterov는 관성으로 이동한 위치에서 gradient를 계산하므로 다음 효과가 발생한다.

• 만약 최소점에 가까워졌다면 → gradient 크기가 작아짐 → 업데이트가 자동으로 완화됨

• 만약 잘못된 방향으로 가고 있다면 → 미래 위치에서 gradient가 즉시 이를 감지 → 보정 방향으로 업데이트

즉, Nesterov는 사전 보정(pre-correction) 을 수행한다.

6.4 Momentum vs Nesterov: 구조적 비교

중요한 점은, 계산 비용은 거의 증가하지 않으면서 수렴 특성이 개선된다는 것이다.

6.5 이론적 관점에서의 의의

Nesterov Accelerated Gradient는 단순한 휴리스틱이 아니다.

• 볼록 최적화(convex optimization) 이론에서
• 최적의 수렴률(optimal convergence rate) 을 가지는 방법으로 증명됨

이 때문에 “Accelerated”라는 이름이 붙었다.

6.6 여전히 남아 있는 문제

Nesterov는 Momentum의 방향성 문제를 상당 부분 해결했지만, 여전히 근본적인 한계를 가진다.

(1) 학습률은 여전히 전역적이다

• 모든 파라미터에 동일한 ( $$\eta$$ )
• 파라미터별 스케일 차이 미반영

(2) gradient 크기 정보는 직접적으로 사용하지 않는다

• 방향은 개선되었으나
• “얼마나 크게 가야 하는가”는 여전히 고정 규칙

이제 질문은 다음으로 넘어간다.

“방향만이 아니라, 파라미터마다 다른 학습률을 쓸 수는 없을까?”

7. AdaGrad

Momentum과 Nesterov는 SGD의 방향성 문제를 상당 부분 해결했다. 그러나 여전히 하나의 근본적인 가정이 남아 있었다.

“모든 파라미터는 같은 크기의 step으로 업데이트되어도 괜찮다.”

AdaGrad는 이 가정을 처음으로 명시적으로 부정한 방법이다. 즉, AdaGrad는 ‘방향’이 아니라 ‘스케일’ 문제를 해결하려는 시도다.

7.1 문제 인식: 왜 전역 학습률은 부적절한가

딥러닝 모델의 파라미터들은 동일한 성격을 가지지 않는다.

• 어떤 파라미터는 자주 업데이트됨
• 어떤 파라미터는 매우 드물게 업데이트됨 (희소 특징)

예를 들어:

• NLP에서의 희소 단어 벡터
• 추천 시스템에서의 희소 사용자/아이템 특성

이 경우 전역 학습률 ( $$\eta$$ )는 다음과 같은 문제를 만든다.

• 자주 등장하는 파라미터 → 과도한 업데이트
• 드물게 등장하는 파라미터 → 학습이 거의 되지 않음

AdaGrad는 다음 질문에서 출발한다.

“파라미터마다 다른 학습률을 쓸 수는 없을까?”

7.2 AdaGrad의 핵심 아이디어

AdaGrad는 각 파라미터에 대해 과거 gradient의 크기 정보를 누적한다.

각 파라미터 ( i )에 대해:

$$\begin{aligned} h_{t,i} &= h_{t-1,i} + g_{t,i}^2
w_{t+1,i} &= w_{t,i} - \frac{\eta}{\sqrt{h_{t,i}} + \epsilon} g_{t,i} \end{aligned} $$ 여기서

• ( $$g_{t,i} = \frac{\partial L}{\partial w_{t,i}}$$ )
• ( $$h_{t,i}$$): 해당 파라미터의 gradient 제곱 누적합

7.3 수식적 의미: 자동 학습률 감소

AdaGrad 업데이트를 해석하면 다음과 같다.

• ( $$h_{t,i}$$ )가 커질수록 → 분모가 커짐 → 해당 파라미터의 유효 학습률 감소

즉,

$$\text{effective learning rate}i = \frac{\eta}{\sqrt{h{t,i}}} $$ 이 구조는 다음 효과를 만든다.

• 자주 업데이트되는 파라미터 → 학습률 자동 감소
• 드물게 업데이트되는 파라미터 → 상대적으로 큰 학습률 유지

이는 희소 특징 학습에 매우 유리하다.

7.4 기하학적 관점: 대각선 Hessian 근사

AdaGrad는 암묵적으로 다음을 수행한다.

• 손실 함수의 곡률(curvature)을 파라미터별로 추정
• Hessian의 대각 성분만 근사적으로 반영

즉, AdaGrad는 다음과 같이 해석할 수 있다.

“기울기가 자주 크던 방향은 조심스럽게, 거의 변하지 않던 방향은 과감하게 움직이자.”

이는 SGD + Momentum 계열과 명확히 다른 관점이다.

7.5 AdaGrad의 결정적 한계

AdaGrad는 개념적으로 매우 강력했지만, 실무에서는 치명적인 문제가 드러났다.

(1) 누적합의 비가역성

$$h_{t,i} = \sum_{k=1}^{t} g_{k,i}^2 $$

• 한 번 커진 ( $$h_{t,i}$$ )는 절대 줄어들지 않음
• 학습이 진행될수록 분모가 계속 증가

결과적으로:

• 학습률이 점점 0에 수렴
• 아직 수렴하지 않은 지점에서도 업데이트가 사실상 멈춤

(2) 비정상(non-stationary) 환경에 부적합

딥러닝 학습에서는:

• 초반과 후반의 gradient 특성이 크게 다름

AdaGrad는 아주 오래된 gradient까지 동일하게 기억하므로, 현재 상황을 제대로 반영하지 못한다.

AdaGrad의 실패는 다음 질문으로 이어진다.

“과거 gradient를 모두 기억할 필요가 있을까?” “최근 gradient에 더 집중할 수는 없을까?”

이 질문에 대한 해답이 바로 RMSProp이다.

• 누적합 → 지수 이동 평균
• 학습률이 0으로 붕괴되는 문제 해결

8. RMSProp

AdaGrad는 파라미터별 학습률이라는 중요한 돌파구를 열었지만, “과거 gradient를 모두 기억한다”는 설계 때문에 학습이 조기에 멈추는 치명적인 한계를 드러냈다.

RMSProp은 이 문제를 다음과 같이 재정의한다.

“과거 gradient가 중요하긴 한데, 모두 동일하게 중요할 필요는 있지 않다.”

즉, RMSProp은 비정상(non-stationary) 환경에서의 통계적 추정 문제로 최적화를 다시 바라본다.

8.1 AdaGrad 실패의 본질적 원인

AdaGrad의 누적 변수는 다음과 같다.

$$h_{t,i} = \sum_{k=1}^{t} g_{k,i}^2 $$ 이 식은 다음 특성을 가진다.

• 시간 (t)가 증가할수록 단조 증가
• 초반의 gradient와 후반의 gradient를 동일하게 취급
• 현재 손실 지형의 변화 반영 불가

즉, AdaGrad는 시간에 따라 변하는 gradient 분포를 전혀 고려하지 않는다.

8.2 RMSProp의 핵심 아이디어

RMSProp은 AdaGrad의 누적합을 지수 이동 평균(Exponential Moving Average, EMA) 으로 대체한다.

$$\begin{aligned} h_{t,i} &= \rho h_{t-1,i} + (1 - \rho) g_{t,i}^2
\end{aligned} $$

$$\begin{aligned} w_{t+1,i} &= w_{t,i} - \frac{\eta}{\sqrt{h_{t,i}} + \epsilon} g_{t,i} \end{aligned} $$ 여기서

• ( $$\rho$$ ): decay rate (보통 0.9 또는 0.99)

8.3 수식적 의미: EMA로서의 분산 추정

RMSProp의 ( h_{t,i} )는 다음과 같이 해석할 수 있다.

$$h_{t,i} \approx \mathbb{E}[g_i^2]$$ 즉, RMSProp은 각 파라미터에 대해

• gradient 제곱의 이동 평균
• gradient 분산(scale)에 대한 추정치

를 유지한다.

이로 인해 다음 효과가 발생한다.

• 과거의 오래된 gradient 영향 감소
• 최근 손실 지형에 빠르게 적응

8.4 AdaGrad 대비 개선점

즉, RMSProp은 “너무 많은 기억”이 문제였음을 정확히 짚고 보완한 방법이다.

8.5 RMSProp의 한계

RMSProp은 스케일 문제를 상당히 잘 해결했지만, 여전히 중요한 정보가 빠져 있다.

(1) 방향성 정보의 부재

• RMSProp은 gradient 크기(scale)만 고려
• Momentum처럼 방향의 일관성은 반영하지 않음

즉, RMSProp은 다음 질문에 답하지 못한다.

“어디로 가야 하는지는 알겠는데, 그 방향이 일관된 방향인가?”

(2) 노이즈에 대한 취약성

• 분산은 조절하지만
• 방향 자체는 여전히 noisy한 gradient에 의존

• Momentum / Nesterov → 방향 문제 해결
• AdaGrad / RMSProp → 스케일 문제 해결

“방향과 스케일을 동시에 다룰 수는 없을까?”

9. Adam (Adaptive Moment Estimation)

Adam은 하나의 새로운 아이디어라기보다, 지금까지 등장한 최적화 기법들이 해결하려 했던 문제들을 하나의 수식 체계로 통합한 결과물이다. SGD가 가진 느린 수렴과 불안정성, Momentum 계열이 해결한 방향성 문제, AdaGrad와 RMSProp이 다룬 파라미터별 스케일 문제는 모두 Adam이라는 프레임 안에서 동시에 고려된다.

즉, Adam은 다음과 같은 질문에 대한 종합적인 해답이다.

“경사는 어느 방향으로 가야 하는가?” “그 방향으로 얼마나 크게 이동해야 하는가?”

Adam은 이 두 질문을 gradient 자체가 아니라, gradient의 통계량을 추정하는 문제로 재정의한다.

9.1 모멘트 추정

Adam의 핵심은 각 파라미터에 대해 두 가지 통계량을 유지하는 것이다.

첫째는 1차 모멘트, 즉 gradient의 평균이다. 이는 Momentum이 하던 역할과 동일하며, 업데이트 방향의 일관성을 확보하는 역할을 한다.

둘째는 2차 모멘트, 즉 gradient 제곱의 평균이다. 이는 RMSProp에서 도입된 개념으로, 파라미터별 gradient 크기(스케일)를 추정한다.

이 두 모멘트는 모두 지수 이동 평균(Exponential Moving Average, EMA)으로 계산된다. 시간 ( t )에서 gradient를 ( $$g_t = \nabla L(W_t)$$ )라 하면,

$$ m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t $$

$$ v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2 $$

여기서 ( $$\beta_1$$ )은 보통 0.9, ( $$\beta_2$$ )는 0.999로 설정된다. 이 선택은 최근 gradient의 방향 정보는 비교적 빠르게 반영하고, 분산 정보는 더 안정적으로 추정하겠다는 의미를 담고 있다.

9.2 바이어스 보정이 필요한 이유

Adam의 모멘트 변수 ( $$m_t, v_t$$ )는 0으로 초기화된다. 이로 인해 학습 초반에는 EMA 특성상 추정치가 실제보다 작게 계산되는 초기 바이어스(bias) 가 발생한다.

이를 보정하지 않으면 초반 학습 단계에서 업데이트가 과도하게 작아지고, Adam의 장점이 충분히 발휘되지 않는다.

이를 해결하기 위해 Adam은 다음과 같은 바이어스 보정식을 적용한다.

$$ \hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t} $$

이 보정은 단순한 트릭이 아니라, Adam이 통계적으로 의미 있는 모멘트 추정기임을 보여주는 중요한 요소다.

9.3 Adam의 최종 업데이트 식

바이어스가 보정된 모멘트를 이용한 Adam의 파라미터 업데이트 식은 다음과 같다.

$$ W_{t+1} = W_t - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} $$

이 수식 하나에는 지금까지의 최적화 기법이 해결해 온 핵심 문제가 모두 녹아 있다.

• Momentum을 통한 방향 안정성
• RMSProp을 통한 파라미터별 스케일 조절
• 비정상적인 손실 지형에 대한 적응
• 학습 초반의 불안정성 완화

이 때문에 Adam은 실무에서 “기본값(default optimizer)”으로 널리 사용된다.

9.4 Adam의 구조적 한계: Weight Decay 문제

Adam의 학습 속도와 안정성에도 불구하고, 실무에서는 한 가지 중요한 문제가 관찰된다. 바로 정규화(regularization)가 의도한 방식으로 동작하지 않을 수 있다는 점이다.

일반적으로 L2 정규화는 손실 함수에 다음 항을 추가하는 방식으로 구현된다.

$$ L'(W) = L(W) + \lambda |W|^2 $$

이 경우 gradient는

$$ g_t = \nabla L(W_t) + \lambda W_t $$

가 된다.

SGD에서는 이 항이 모든 파라미터를 동일한 비율로 줄이는 균등한 수축(shrinkage) 으로 작동한다. 그러나 Adam에서는 gradient가 모멘트와 분산으로 변환되기 때문에, 이 정규화 항마저도 파라미터별로 서로 다른 스케일을 갖게 된다.

그 결과, Adam에서의 weight decay는 “모든 가중치를 일정 비율로 줄인다”는 원래의 의미를 잃고, gradient 통계에 따라 왜곡된 형태로 적용된다.

이는 Adam이 훈련 데이터에서는 빠르게 수렴하지만, 테스트 성능에서는 불안정해지는 현상의 주요 원인 중 하나로 지목된다.

9.5 AdamW: 최적화와 정규화의 분리

AdamW는 이 문제를 매우 단순한 질문으로 환원한다.

“Weight decay는 최적화 문제가 아니라, 파라미터 크기를 제어하는 규칙 아닌가?”

이에 따라 AdamW는 gradient 기반 업데이트와 weight decay를 완전히 분리한다.

먼저 Adam 방식으로 파라미터를 업데이트하고,

$$ W_{t+\frac{1}{2}} = W_t - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} $$

그 다음, gradient와 무관하게 weight decay를 적용한다.

$$W_{t+1} = W_{t+\frac{1}{2}} - \eta \lambda W_t$$

이렇게 함으로써 AdamW는 Adam의 빠른 수렴 특성과 SGD에서 의도한 정규화 효과를 동시에 유지한다.

10. 초기화와 최적화의 상호작용

딥러닝 학습은 흔히 “좋은 모델 구조 + 좋은 optimizer”의 문제로 단순화되곤 한다. 그러나 실제로 학습의 성패를 좌우하는 것은 초기화와 최적화가 함께 만들어내는 학습 동역학(dynamics) 이다.

이 챕터에서는 지금까지 다룬 내용을 바탕으로, 초기화와 최적화가 어떻게 상호작용하는지, 그리고 실무에서 어떤 기준으로 최적화 기법을 선택해야 하는지를 정리한다.

10.1 초기화와 최적화는 독립적인 문제가 아니다

가중치 초기화는 단순히 “시작점”을 정하는 문제가 아니다. 초기화는 학습 초반의 손실 지형과 gradient 분포를 결정하고, 이는 곧 optimizer가 어떤 정보를 보게 되는지를 결정한다.

예를 들어,

• 잘못된 초기화 → 활성화 값 포화 → gradient vanishing → 어떤 optimizer를 써도 학습 불가

• Xavier / He 초기화 → 층별 분산 안정 → gradient 신호 유지 → optimizer가 제 역할을 수행할 수 있는 환경 제공

즉, 초기화는 optimizer의 성능을 발휘 가능하게 만드는 전제 조건이다.

10.2 SGD 계열은 언제 사용하면 좋은가

SGD와 그 변형(Momentum, Nesterov)은 구조적으로 단순하다.

$$ W_{t+1} = W_t - \eta \nabla L(W_t) $$

또는 방향성을 보완한 형태일 뿐이다. 이 단순함은 다음과 같은 상황에서 강점으로 작용한다.

SGD 계열이 유리한 경우

• 데이터가 충분히 많고
• 학습 시간이 상대적으로 길어도 괜찮으며
• 일반화 성능이 중요한 경우

SGD는 gradient의 노이즈를 그대로 유지한다. 이 노이즈는 단점처럼 보이지만, 실제로는 날카로운(local sharp) 최소점에 빠지는 것을 방지하고, 더 평평한(flat) 최소점으로 이동하게 만든다.

이 때문에 다음과 같은 경험적 관찰이 자주 성립한다.

“SGD는 느리게 학습되지만, 테스트 성능은 더 좋다.”

10.3 Adam 계열은 언제 사용하면 좋은가

Adam과 AdamW는 다음과 같은 환경에서 특히 강력하다.

• 학습 초반이 불안정한 경우
• gradient 스케일이 파라미터마다 크게 다른 경우
• 비정상(non-stationary) 손실 지형
• 빠른 수렴이 중요한 경우

Adam 계열은 파라미터별로 학습률을 자동 조절하고, 방향성과 스케일을 동시에 고려한다. 그 결과, 하이퍼파라미터 튜닝 부담이 낮고, “일단 잘 돌아가는 모델”을 빠르게 얻을 수 있다.

그래서 실무에서는 흔히 다음 전략을 취한다.

• 초기 실험 → Adam / AdamW
• 모델 검증 후 → SGD 계열로 전환 여부 검토

10.4 왜 AdamW가 기본값이 되었는가

앞 장에서 보았듯이, AdamW는 Adam의 구조적 문제였던 weight decay 왜곡을 해결한다. 이는 단순한 성능 개선이 아니라, 최적화와 정규화의 역할을 명확히 분리했다는 점에서 의미가 크다.

현재의 딥러닝 학습 환경은 다음과 같은 특성을 가진다.

• 매우 깊은 모델
• LayerNorm, Residual Connection 등으로 gradient 흐름이 복잡
• 대규모 데이터와 배치

이 환경에서는 AdamW의 다음 특성이 특히 중요하다.

• 안정적인 초기 학습
• 명확한 정규화 해석
• 큰 모델에서도 일관된 동작

이로 인해 AdamW는 현재 사실상의 표준(default optimizer)로 자리 잡았다.

10.5 선택 가이드

인공지능 연구의 핵심 목표 중 하나는 인간의 사고 과정을 수학적·계산적으로 모사하는 것이다. 이러한 시도의 출발점은 뉴런(neuron) 이라는 생물학적 개념에 있다. 인간의 뇌는 수많은 뉴런이 서로 연결되어 정보를 전달하고 처리함으로써 복잡한 판단을 수행한다. 인공 신경망(Artificial Neural Network)은 이 구조를 단순화하여 컴퓨터에서 구현한 모델이다.

이 장에서는 인공 신경망의 가장 기본적인 구성 요소인 퍼셉트론(perceptron) 과, 그 한계를 극복하기 위해 제안된 다층 퍼셉트론(multi-layer perceptron) 을 살펴본다.

2. 퍼셉트론: 가장 단순한 인공 뉴런

퍼셉트론은 입력값을 활성화함수(activation function) 에 통과시켜 일정한수준(threshold) 을 넘으면 True 아니면 False를 내보내는 간단한 회로이다. 이는 인공 신경망을 구성하는 가장 기본적인 계산 단위이며, 입력 값과 활성화 함수를 사용해 출력 값을 넘기는 가장 작은 신경망 단위이다.

구조는 매우 단순하다.

퍼셉트론은 여러 개의 입력값을 받아 각 입력에 대응하는 가중치를 곱한 뒤, 이들의 합에 바이어스를 더한다. 이렇게 계산된 가중합은 활성화 함수를 통과하여 최종 출력값을 결정한다.

이를 수식으로 표현하면 다음과 같다.

$$y = \tau\left(\sum_{i=1}^{d} w_i x_i + b\right)$$

여기서

• (x_i)는 입력값
• (w_i)는 가중치
• (b)는 바이어스
• ($$\tau(\cdot)$$)는 활성화 함수이다.

활성화 함수란, 전통적으론 가중 합의 결과로부터 0또는 1을 출력하는 함수다. (현재의 활성화 함수는 가중합에 비선형을 더해주는 임의의 함수다.)

초기의 퍼셉트론에서 활성화 함수는 임계값 함수(threshold function)를 사용하였다. 가중합이 0보다 크면 1을 출력하고, 그렇지 않으면 0을 출력한다. 따라서 퍼셉트론은 본질적으로 이진 분류기(binary classifier) 로 볼 수 있다.

3. 퍼셉트론과 선형 분리

퍼셉트론이 해결할 수 있는 문제에는 중요한 제약 조건이 있다. 퍼셉트론은 입력 공간에서 하나의 직선(또는 고차원에서는 초평면) 으로 클래스가 구분 가능한 경우에만 정상적으로 작동한다. 이를 선형 분리 가능(linearly separable) 하다고 한다.

예를 들어 AND, OR 논리 연산은 입력 공간에서 하나의 직선으로 True와 False를 구분할 수 있기 때문에 퍼셉트론으로 구현이 가능하다. 반면 XOR 논리 연산은 동일한 방식으로는 해결할 수 없다.

4. XOR 문제와 퍼셉트론의 한계

XOR 문제는 퍼셉트론의 구조적 한계를 가장 명확하게 보여주는 예제이다. XOR 연산은 두 입력이 서로 다를 때만 True를 출력한다. 하지만 이 네 개의 입력 조합은 어떤 하나의 직선으로도 분리할 수 없다.

이 사실은 1969년 Marvin Minsky가 『Perceptrons』에서 지적하였으며, 이는 당시 인공지능 연구에 큰 영향을 미쳤다. 퍼셉트론을 단순히 확장하는 방식만으로는 일반적인 지능을 구현하기 어렵다는 인식이 확산되었고, 인공지능 연구는 한동안 침체기를 겪게 된다.

5. 다층 퍼셉트론의 등장

퍼셉트론의 한계를 극복하기 위한 핵심 아이디어는 다음과 같다.

하나의 직선으로 분리할 수 없다면, 여러 번 나누면 되지 않을까?

이 생각에서 출발한 모델이 다층 퍼셉트론(Multi-layer Perceptron, MLP) 이다. 다층 퍼셉트론은 퍼셉트론을 여러 층으로 쌓아 구성한다. 일반적으로 입력층과 출력층 사이에 하나 이상의 은닉층(hidden layer) 을 둔다.

은닉층의 퍼셉트론들은 단순한 분류기가 아니라, 입력 데이터를 새로운 표현 공간으로 변환하는 역할을 한다. 이를 통해 선형 분리가 불가능했던 문제를 선형 분리가 가능한 형태로 바꿀 수 있다.

이 구조를 사용하면 XOR 문제 역시 간단히 해결할 수 있다.

6. 은닉층의 역할: 공간의 변환

은닉층의 본질적인 역할은 좌표 공간의 변환이다. 입력 데이터를 다른 공간으로 사상(mapping)함으로써, 기존 공간에서는 복잡하게 얽혀 있던 데이터가 새로운 공간에서는 단순한 경계로 분리될 수 있도록 만든다.

이 관점에서 보면,

• 퍼셉트론은 분류기이며
• 은닉층은 특징 추출기(feature extractor)라고 할 수 있다.

때문에, XOR 문제를 해결하기 위해서는 좌표 평면 자체에 변환을 주어야 하며, 이를 가능하게 하려면 숨어있는 층인 은닉층을 만들어야 한다.

은닉층은 좌표 평면의 왜곡이며, 다른 공간으로의 변환 (차원 확대 또는 축소)라고 볼 수 있다. 이 아이디어는 이후 딥러닝 전반에서 매우 중요한 개념으로 확장된다.

다시 XOR 문제로 넘어가면,

7. 다층 퍼셉트론의 학습과 기울기 소실 문제

다층 퍼셉트론은 구조적으로는 강력하지만, 학습 과정에서 새로운 문제를 야기한다. 신경망은 일반적으로 경사하강법(gradient descent) 과 역전파(backpropagation) 알고리즘을 사용해 학습한다.

경사하강법과 역전파 알고리즘

다층 퍼셉트론은 구조적으로는 강력하지만, 학습 과정에서 새로운 문제를 야기한다. 신경망은 일반적으로 경사하강법(gradient descent) 과 역전파(backpropagation) 알고리즘을 사용해 학습한다. 이 절에서는 이 두 개념이 무엇이며, 왜 함께 사용되는지를 설명한다.

경사하강법(Gradient Descent)

경사하강법은 신경망 학습에서 손실 함수(loss function)를 최소화하기 위한 최적화 기법이다. 신경망의 목표는 입력에 대한 예측값과 실제 정답 사이의 차이를 줄이는 것이며, 이 차이를 수치적으로 표현한 것이 손실 함수이다.

신경망의 모든 가중치와 바이어스를 변수로 생각하면, 손실 함수는 이 변수들에 의해 결정되는 하나의 함수가 된다. 학습이란 이 함수가 최소가 되는 지점을 찾는 과정이라고 볼 수 있다.

경사하강법의 핵심 아이디어는 다음과 같다.

현재 위치에서 손실 함수의 값이 가장 빠르게 감소하는 방향은 그 지점에서의 기울기(gradient)의 반대 방향이다.

이를 바탕으로 경사하강법은 각 가중치를 다음과 같은 규칙으로 업데이트한다.

$$w \leftarrow w - \eta \frac{\partial L}{\partial w}$$

여기서

• ( $$\frac{\partial L}{\partial w}$$ )는 가중치 (w)에 대한 손실 함수의 기울기
• ( $$\eta$$ )는 학습률(learning rate)로, 한 번의 업데이트에서 이동하는 크기를 의미한다.

즉, 경사하강법은 손실을 증가시키는 방향의 반대로 가중치를 조금씩 조정함으로써 모델의 성능을 점진적으로 개선한다.

역전파(Backpropagation)

경사하강법을 적용하기 위해서는 각 가중치에 대해 손실 함수의 기울기를 계산해야 한다. 그러나 다층 퍼셉트론에서는 출력이 여러 층의 연속적인 연산을 거쳐 계산되기 때문에, 이 미분을 직접 계산하는 것은 매우 비효율적이다.

이 문제를 해결하기 위해 사용되는 알고리즘이 역전파(backpropagation) 이다. 역전파는 출력층에서 계산된 오차를 입력층 방향으로 전달하면서, 각 층의 가중치가 손실에 얼마나 기여했는지를 계산한다.

역전파의 핵심은 미분의 연쇄 법칙(chain rule) 이다. 신경망의 출력은 여러 함수가 중첩된 형태이므로, 전체 미분은 각 단계의 미분을 곱한 형태로 표현된다.

역전파 과정은 다음과 같은 순서로 이루어진다.

1. 순전파(forward propagation) 입력층에서 시작해 은닉층을 거쳐 출력층까지 값을 계산한다.
2. 손실 계산 출력값과 실제 정답을 비교하여 손실 함수를 계산한다.
3. 역전파(backward propagation) 출력층부터 입력층 방향으로 기울기를 전달하며 각 가중치에 대한 미분값을 계산한다.
4. 가중치 업데이트 계산된 기울기를 사용해 경사하강법으로 가중치를 수정한다.

즉, 역전파는 경사하강법에 필요한 기울기를 효율적으로 계산하는 알고리즘이라고 할 수 있다.

기울기 소실 문제와의 연결

역전파 과정에서 각 층의 기울기는 여러 미분값의 곱으로 표현된다. 만약 각 층에서의 미분값이 1보다 작다면, 이 곱은 층이 깊어질수록 급격히 작아진다. 그 결과 입력층에 가까운 가중치들은 거의 업데이트되지 않게 된다.

이 현상을 기울기 소실(vanishing gradient) 문제라고 하며, 이는 전통적인 다층 퍼셉트론에서 학습이 어려웠던 주요 원인 중 하나이다. 특히 시그모이드 함수와 같이 미분값이 작은 활성화 함수를 사용할 경우, 이 문제가 더욱 심각하게 나타난다.

정리

경사하강법과 역전파는 역할이 명확히 구분된다.

• 경사하강법은 가중치를 어느 방향으로, 얼마나 변경할지를 결정하는 방법이며
• 역전파는 그 방향을 계산하기 위해 필요한 기울기를 계산하는 방법이다.

따라서 다층 퍼셉트론의 학습에서 두 알고리즘은 항상 함께 사용되며, 이후 등장하는 딥러닝 모델에서도 동일한 원리가 적용된다.

8. 활성화 함수와 기울기 소실

기울기 소실 문제의 주요 원인 중 하나는 전통적으로 활성화 함수로 사용되던 시그모이드(sigmoid) 함수의 특성이다. 시그모이드 함수는 출력값이 0과 1 사이로 제한되며, 미분값의 최대도 매우 작다. 따라서 여러 층을 거치면 기울기가 거의 0에 수렴하게 된다.

이 문제를 해결하기 위해 최근의 신경망에서는 은닉층의 활성화 함수로 ReLU(Rectified Linear Unit) 가 주로 사용된다. ReLU는 양수 영역에서 기울기가 1이므로, 깊은 신경망에서도 기울기가 비교적 안정적으로 전달된다.

왜 초기 다층 퍼셉트론에서는 시그모이드 함수를 사용했는가

오늘날의 신경망에서는 은닉층의 활성화 함수로 ReLU가 표준처럼 사용되지만, 초기 다층 퍼셉트론에서는 대부분 시그모이드(sigmoid) 함수가 사용되었다. 이는 단순한 관성이나 우연이 아니라, 당시의 이론적 배경과 기술적 제약에 따른 합리적인 선택이었다.

생물학적 뉴런 모델과의 유사성

초기 인공 신경망 연구는 생물학적 뉴런을 모사하는 데서 출발했다. 시그모이드 함수는 입력이 증가함에 따라 출력이 점진적으로 증가하다가 포화되는 형태를 갖는데, 이는 뉴런의 발화(firing) 특성과 유사하다고 여겨졌다.

특히 시그모이드 함수는 다음과 같은 특징을 가진다.

• 입력이 작을 때는 거의 0
• 특정 임계 구간에서는 민감하게 반응
• 입력이 충분히 크면 출력이 1에 가까워짐

이러한 형태는 “뉴런이 자극의 강도에 따라 발화 확률이 증가한다”는 직관적 해석과 잘 맞아떨어졌기 때문에, 시그모이드는 생물학적으로 타당한 활성화 함수로 받아들여졌다.

미분 가능성과 수학적 안정성

퍼셉트론의 학습에는 미분이 필수적이다. 역전파 알고리즘을 적용하려면 활성화 함수가 연속적이고 미분 가능해야 한다.

시그모이드 함수는 다음과 같은 장점을 갖는다.

• 모든 구간에서 미분 가능
• 함수 형태가 부드럽고 연속적
• 미분식이 간단함

$$\sigma'(x) = \sigma(x)(1 - \sigma(x))$$

이 단순한 미분 형태는 초기 신경망 연구에서 이론 분석과 구현을 매우 용이하게 했다. 반면, ReLU와 같은 함수는 0에서 미분이 정의되지 않기 때문에 초기에는 수학적으로 다루기 어렵다고 여겨졌다.

확률적 해석이 가능함

시그모이드 함수의 출력은 항상 0과 1 사이에 위치한다. 이 특성은 출력을 확률로 해석하는 데 매우 유리하다.

특히 이진 분류 문제에서 시그모이드 출력은

$$P(y = 1 \mid x)$$

로 해석될 수 있다. 이 관점은 이후 로지스틱 회귀(logistic regression)와 신경망을 연결하는 중요한 이론적 기반이 되었다.

초기 연구자들은 은닉층에서도 이러한 “확률적 활성화”가 유의미할 것이라 기대했고, 이는 시그모이드를 은닉층까지 확장해 사용하는 계기가 되었다.

당시에는 ‘깊은 신경망’이 현실적이지 않았음

기울기 소실 문제는 신경망이 깊어질 때 본격적으로 문제가 된다. 그러나 초기 인공 신경망 연구에서는 다음과 같은 현실적 제약이 있었다.

• 은닉층 수가 매우 적음 (1~2층 수준)
• 데이터 규모가 작음
• 계산 자원이 극히 제한적임

이러한 환경에서는 시그모이드의 단점이 심각하게 드러나지 않았다. 오히려 부드럽고 안정적인 시그모이드가 학습을 더 잘 수렴시키는 경우도 많았다.

즉, 당시의 문제 설정에서는 시그모이드는 충분히 잘 작동하는 함수였다.

문제는 ‘시그모이드’ 자체가 아니라, 깊이가 깊어졌을 때였다

중요한 점은 다음이다.

시그모이드 함수는 잘못된 선택이 아니었다. 문제는 시그모이드를 사용한 채로 신경망을 깊게 쌓으려 했다는 데 있다.

층이 깊어질수록 시그모이드의 미분값이 0에 가까워지면서 기울기 소실 문제가 발생했고, 이는 깊은 신경망의 학습을 어렵게 만들었다. 이 한계를 인식하고 극복하는 과정에서 ReLU, 가중치 초기화 기법, 정규화 기법 등이 등장하며 딥러닝이 본격적으로 발전하게 된다.

9. 계산 그래프를 이용한 오차 역전파

앞 절에서 살펴본 역전파 알고리즘은 미분의 연쇄 법칙(chain rule)에 기반한다. 그러나 실제 신경망은 수많은 연산이 중첩된 매우 복잡한 함수 형태를 가지므로, 이를 수식으로 직접 미분하는 것은 비현실적이다. 이 문제를 체계적으로 해결하기 위해 도입된 개념이 계산 그래프(computational graph) 이다.

계산 그래프의 개념

계산 그래프는 하나의 함수를 연산 단위로 분해하여 그래프 형태로 표현한 것이다.

• 노드(node) 는 연산(덧셈, 곱셈, 활성화 함수 등)을 나타내고
• 간선(edge) 은 연산 사이를 오가는 데이터(값 또는 미분값)를 나타낸다.

이러한 표현 방식의 핵심 장점은, 복잡한 함수라도 국소적인 계산(local computation) 들의 조합으로 이해할 수 있다는 점이다.

순전파와 역전파

계산 그래프에서는 모든 계산이 두 단계로 나뉜다.

순전파 (Forward Propagation)

순전파는 입력으로부터 출력을 계산하는 과정이다. 계산 그래프의 왼쪽에서 오른쪽으로 연산을 수행하며, 각 노드에서 중간 결과를 저장한다. 이 단계에서 신경망은 주어진 입력에 대한 예측값을 계산한다.

역전파 (Backward Propagation)

역전파는 출력에서 발생한 오차가 각 연산과 가중치에 어떻게 영향을 미쳤는지를 계산하는 과정이다. 계산 그래프의 오른쪽에서 왼쪽으로 진행하며, 각 노드에서 출력에 대한 입력의 미분값을 계산한다.

이때 핵심 원리는 다음과 같다.

전체 미분은 각 연산의 국소 미분을 곱하여 전달할 수 있다.

이는 미분의 연쇄 법칙을 계산 그래프 형태로 구현한 것이다.

연쇄 법칙과 계산 그래프

함수가 다음과 같이 여러 함수의 합성으로 이루어져 있다고 하자.

$$a = h(g(f(x)))$$

이때 (a)를 (x)에 대해 미분하면,

$$ \frac{da}{dx}=

\frac{da}{dz} \cdot \frac{dz}{dy} \cdot \frac{dy}{dx} $$

와 같이 표현된다. 계산 그래프는 이 과정을 시각적이고 기계적으로 처리할 수 있게 해준다.

각 노드는 자신이 수행한 연산에 대해서만 미분을 계산하고, 그 결과를 이전 노드로 전달한다. 이 방식 덕분에 복잡한 함수도 전체 형태를 다시 보지 않고 미분할 수 있다.

기본 연산 노드의 역전파

계산 그래프에서 자주 등장하는 연산들은 다음과 같은 단순한 역전파 규칙을 갖는다.

• 덧셈 노드

  출력의 기울기가 그대로 각 입력으로 전달된다.

• 곱셈 노드

  한 입력에 대한 기울기는 다른 입력값을 곱한 형태로 전달된다.

RELU의 역전파

ReLU(Rectified Linear Unit)는 은닉층에서 가장 널리 사용되는 활성화 함수로, 다음과 같이 정의된다. $$y = \mathrm{ReLU}(x) = \max(0, x)$$ 역전파에서 입력 (x)에 대한 손실 함수 (L)의 기울기는 다음과 같이 계산된다. $$ \frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \cdot \frac{dy}{dx} $$ 따라서 ReLU 계층의 역전파는 ($$\frac{dy}{dx}$$), 즉 ReLU 함수의 미분값에 의해 결정된다.

입력이 양수인 경우 ((x > 0))

• 순전파 입력 (x > 0) 이므로 출력은 (y = x) 이다.

• 미분값 이 구간에서 ReLU는 항등 함수(identity function)이므로, $$ \frac{dy}{dx} = 1 $$

• 역전파 $$

  \frac{\partial L}{\partial x}

  \frac{\partial L}{\partial y} $$ 즉, 출력 쪽에서 전달된 기울기가 감소나 변화 없이 그대로 입력 쪽으로 전달된다. 그림에서 빨간 화살표가 끊기지 않고 그대로 이어지는 이유가 바로 이 때문이다.

** 입력이 0 이하인 경우 (($$x \le 0$$)) **

• 순전파 입력 ($$x \le 0$$) 이므로 출력은 (y = 0) 이다.
• 미분값 이 구간에서 ReLU는 상수 함수이므로, $$\frac{dy}{dx} = 0$$
• 역전파 $$\frac{\partial L}{\partial x}=0$$ 즉, 출력 쪽에서 전달된 기울기가 입력 쪽으로 전혀 전달되지 않고 차단된다. 그림에서 입력 방향으로의 기울기가 0으로 표시되는 이유가 여기에 있다.

위와같은 이유로 RELU는 입력이 양수인 영역에서는 기울기가 1로 유지되어 기울기 소실 문제를 완화한다. 또한, 계산이 단순하여 학습 속도가 빠르고 구현이 용이하다.

다만, 입력이 항상 0 이하로 유지되는 뉴런은 기울기가 계속 0이 되어 더 이상 학습되지 않는 문제가 발생할 수 있으며, 이를 Dead ReLU 문제라고 한다. 이 문제를 완화하기 위해 Leaky ReLU, PReLU 등의 변형 함수가 제안되었다.

sigmoid의 역전파

Sigmoid 계층의 계산 그래프와 오차 역전파

Sigmoid 함수는 다음과 같이 정의된다.

$$y = \sigma(x) = \frac{1}{1 + \exp(-x)}$$

Sigmoid는 하나의 함수처럼 보이지만, 계산 그래프 관점에서는 여러 개의 기본 연산으로 분해할 수 있다. 이러한 분해는 오차 역전파를 이해하는 데 매우 중요하다.

Sigmoid 함수의 계산 그래프 분해

Sigmoid 함수는 다음과 같은 연산들의 조합으로 표현된다.

1. 입력 (x)에 (-1)을 곱해 (-x)를 계산
2. ($$\exp(-x)$$) 계산
3. ($$1 + \exp(-x)$$) 계산
4. 역수 연산을 통해 $$y = \frac{1}{1 + \exp(-x)}$$ 계산

순전파 (Forward Propagation)

순전파에서는 계산 그래프의 왼쪽에서 오른쪽으로 연산이 진행된다.

• 입력 (x) → (-x)
• ($$-x$$) → ($$\exp(-x)$$)
• ($$\exp(-x)$$) → ($$1 + \exp(-x)$$)
• 최종 출력 (y)

이 과정에서 각 노드의 출력값은 역전파를 위해 저장된다.

역전파 (Backward Propagation)의 목표

역전파의 목적은 다음 값을 계산하는 것이다.

$$\frac{\partial L}{\partial x}$$

즉, 출력 (y)에 대한 손실 함수의 기울기 ($$\frac{\partial L}{\partial y}$$)가 주어졌을 때, 이 오차가 입력 (x)에 어떻게 전달되는지를 계산한다.

단계별 오차 역전파 설명

이제 그림의 아래쪽(빨간 화살표) 을 따라, 오른쪽에서 왼쪽으로 역전파를 진행한다.

1) 1단계: 나눗셈(역수) 노드

$$y = \frac{1}{u}, \quad u = 1 + \exp(-x)$$

미분하면,

$$\frac{dy}{du} = -\frac{1}{u^2} = -y^2$$

따라서 역전파 기울기는

$$\frac{\partial L}{\partial u} =\frac{\partial L}{\partial y} \cdot (-y^2)$$

그림에서 ($$-\frac{\partial L}{\partial y} y^2$$) 가 표시된 이유가 바로 이 때문이다.

2) 2단계: 덧셈 노드 $$u = 1 + \exp(-x)$$

덧셈 연산의 미분값은 항상 1이므로,

$$\frac{\partial L}{\partial \exp(-x)}=\frac{\partial L}{\partial u}$$

즉, 기울기는 그대로 전달된다.

3) 3단계: 지수(exp) 노드

$$v = \exp(-x)$$

미분하면,

$$\frac{dv}{d(-x)} = \exp(-x)$$

따라서,

$$\frac{\partial L}{\partial (-x)} =\frac{\partial L}{\partial v} \cdot \exp(-x)$$

4) 4단계: 곱셈 노드 ($$(-1 \times x)$$)

$$* x = (-1) \cdot x $$

이 경우, $$ \frac{d(-x)}{dx} = -1 $$

따라서 최종적으로,

$$ \frac{\partial L}{\partial x} =* \frac{\partial L}{\partial (-x)} $$

위의 모든 단계를 곱하면 다음과 같은 결과를 얻는다.

$$ \frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \cdot y (1 - y) $$

이는 Sigmoid 함수의 잘 알려진 미분 결과이다.

이 과정에서 중요한 점은 다음이다.

• Sigmoid의 복잡한 미분 공식을 외울 필요가 없다
• 각 노드는 자신의 연산에 대한 국소 미분만 계산한다
• 전체 미분은 국소 미분들의 곱으로 자동 완성된다

즉, 계산 그래프는 복잡한 함수의 미분을 기계적으로 수행할 수 있게 해주는 도구이다.

Sigmoid 역전파와 기울기 소실 문제

Sigmoid의 미분값은 $$y(1 - y)$$ 이며, 이 값은 항상 0과 0.25 사이에 존재한다. 따라서 Sigmoid 계층이 여러 층 반복되면 기울기는 계속 작아지며, 깊은 신경망에서는 기울기 소실 문제가 발생하게 된다.

본 연구의 목적은 산업 제어 시스템(ICS)의 사이버 보안 강화를 위해 높은 탐지 성능과 해석 가능성을 동시에 갖춘 이상 탐지(Anomaly Detection, AD) 방법론을 제안하는 것이다.

이를 위해 LSTM 오토인코더(Autoencoder) 와 단일 클래스 서포트 벡터 머신(OCSVM) 을 결합한 하이브리드 이상 탐지 모델을 구성하고, 여기에 Gradient SHAP 기반의 설명 가능한 인공지능(XAI) 모듈을 통합하였다.

제안한 방법은 SCADA(Secure Water Treatment) 계열 데이터셋 중 Gas Pipeline 데이터셋을 활용하여 평가되었으며, 기존 방법론 대비 Recall 96.28%, F1-Score 90.12%로 우수한 탐지 성능을 보였다.

또한 XAI 모듈을 통해 이상 징후 판단에 가장 크게 기여한 특징(feature)을 시각적으로 해석함으로써, 엔지니어가 해당 이상이 실제 사이버 공격인지, 혹은 시스템/센서 오작동인지를 보다 신속하게 판단하고 대응할 수 있도록 지원한다.

2. 핵심 용어 및 개념 정리

ICS (Industrial Control Systems)

전력, 가스, 물 공급 등 국가 기반 시설의 운영을 제어·관리하는 산업 제어 시스템을 의미한다. 최근 IoT, 클라우드, AI 기술과 결합되면서 보안 위협이 증가하고 있다.

AD (Anomaly Detection)

정상적인 데이터 패턴에서 벗어난 비정상 행위 또는 이벤트를 탐지하는 기술로, ICS 환경에서는 사이버 침입 및 시스템 공격 방지에 핵심적인 역할을 한다.

LSTM Autoencoder

시계열 데이터의 압축 표현 학습을 위해 인코더와 디코더 모두에 LSTM 셀을 사용하는 오토인코더 구조이다. 시간 의존성이 강한 데이터에서 정상 패턴을 효과적으로 학습할 수 있다.

OCSVM (One-Class Support Vector Machine)

정상 데이터만을 학습하여, 새로운 입력 데이터가 정상 범주에 속하는지 여부를 판별하는 단일 클래스 분류 기반 이상 탐지 알고리즘이다.

XAI (Explainable Artificial Intelligence)

AI 모델의 예측 결과와 내부 작동 과정을 사람이 이해할 수 있도록 설명하는 기술로, 산업 현장에서 모델 신뢰성을 확보하는 데 중요하다.

SHAP (SHapley Additive exPlanations)

게임 이론의 Shapley 값을 기반으로, 각 특징(feature)이 예측 결과에 기여한 정도를 정량적으로 추정하는 XAI 기법이다.

Gradient SHAP

딥러닝 모델에 적합한 SHAP 근사 기법으로, 기준선(baseline) 분포에서 무작위 샘플링을 수행하고 기울기(gradient)의 기댓값을 계산하여 SHAP 값을 추정한다. Deep SHAP 대비 계산 비용이 낮다.

3. Method

3.1 하이브리드 이상 탐지 모델

(LSTM Autoencoder – OCSVM) 그림 1은 본 연구에서 제안한 LSTM Autoencoder–OCSVM 기반 이상 탐지 모델과 Gradient SHAP 기반 XAI 모듈의 전체 처리 흐름을 나타낸다.

입력 시계열 데이터는 길이 𝑙의 슬라이딩 윈도우(sliding window) 를 통해 겹치는 시퀀스로 분할된다. 각 시퀀스는 LSTM Autoencoder의 인코더를 통해 시간 의존성을 반영한 잠재 표현(latent representation)으로 압축되며, 디코더를 통해 원래 시퀀스로 재구성된다.

이후 입력 시퀀스 𝑋𝑖와 재구성된 시퀀스 𝑋^𝑖 간의 재구성 오차(reconstruction error) 가 계산되며, 해당 오차 정보는 OCSVM(One-Class Support Vector Machine) 모델의 입력으로 전달된다. OCSVM은 정상 데이터 분포로부터 학습된 결정 경계를 기반으로, 해당 시퀀스가 정상(normal) 범주에 속하는지 또는 이상(anomalous)인지 여부를 판별한다.

이상으로 탐지된 시퀀스에 대해서는 설명 가능성 확보를 위한 XAI 모듈이 추가적으로 적용된다. Gradient SHAP을 사용하기 위해, 사전 학습된 LSTM Autoencoder의 가중치를 전이한 설명자(Explainer) 모델을 구성하며, 이때 모델 상단에 Flatten 레이어를 추가하여 SHAP 값 계산이 가능하도록 구조를 수정한다. 설명자 모델은 학습 데이터로부터 추출된 background 데이터와 이상 시퀀스를 입력으로 받아, 각 특징(feature)이 이상 예측에 기여한 정도를 Shapley 값 형태로 시각화한다.

이를 통해 제안된 파이프라인은 (1) LSTM Autoencoder를 통한 시계열 표현 학습, (2) OCSVM을 통한 안정적인 이상 판별, (3) Gradient SHAP을 통한 이상 원인 해석 을 단계적으로 수행하며, 높은 탐지 성능과 모델 투명성을 동시에 만족하는 ICS 이상 탐지 구조를 제공한다.

데이터 전처리

입력 데이터 $X = {x_1, x_2, \dots, x_n}$ 를 길이 (l)의 슬라이딩 윈도우(sliding window) 를 사용해 겹치는 시퀀스로 분할한다.

LSTM Autoencoder의 역할

• 입력 시퀀스를 인코딩하여 저차원 압축 표현(latent representation) 학습
• 디코더를 통해 원래 시퀀스로 재구성
• 입력과 출력 간의 재구성 손실(reconstruction loss) 계산

LSTM Autoencoder는 정상 시계열의 구조적 패턴 학습에만 집중한다.

OCSVM의 역할

• LSTM Autoencoder에서 계산된 재구성 손실 정보를 입력으로 사용
• 새로운 시퀀스가 정상 범주에 속하는지 여부를 최종 판별

이를 통해 임계값 설정의 불안정성을 완화하고, 이상 판별을 보다 명확하게 수행한다.

성능 최적화 기준

ICS 환경 특성상 실제 이상을 놓치는 비용이 크므로,

• Precision보다 Recall과 F1-Score를 우선적으로 고려
• 약간의 오탐(False Positive)을 감수하더라도 이상 탐지율 극대화 목표

3.2 설명 가능성 모듈 (XAI Module)

SHAP 값 계산

각 슬라이딩 윈도우 단위 샘플에 대해 Shapley 값을 계산하여,

• 어떤 특징이
• 어느 정도로 이상 예측에 기여했는지 분석한다.

Gradient SHAP 적용 이유

LSTM Autoencoder의 출력은 벡터 형태를 가지므로,

• 계산 비용이 높은 Deep SHAP 대신
• 딥러닝 모델에 적합한 Gradient SHAP을 사용

모델 구조 수정

Gradient SHAP 계산을 위해,

• 사전 학습된 LSTM Autoencoder의 가중치를 전이(transfer)
• 상단에 Flatten 레이어를 추가한 별도의 설명자(Explainer) 모델 구성

해석 방식

계산된 SHAP 값을 시각화하여,

• 예측된 이상 징후에 대해
• 특징(feature)별 기여 비율을 직관적으로 확인한다.

4. Results

4.1 성능 평가

(Gas Pipeline SCADA Dataset)

실험은 Gas Pipeline SCADA 데이터셋을 사용하여 수행되었다.

• 학습 데이터: 정상 샘플 40,192개
• 테스트 데이터: 정상 + 비정상 샘플 10,048개 (이상 비율 약 20%)

평가 지표는 Precision, Recall, F1-Score를 사용하였다.

제안한 LSTM Autoencoder–OCSVM 모델은 다음과 같은 성능을 보였다.

• Recall: 96.28%
• F1-Score: 90.12%

이는 K-means–CAE, SVM, 단독 LSTM 모델 등 기존 방법론 대비 우수한 결과로, 실제 ICS 사이버 보안 환경에서의 활용 가능성을 보여준다.

이 장에서는 회귀와 분류 문제를 중심으로, 대표적인 평가 지표들의 정의, 해석, 사용 시점과 주의점을 체계적으로 정리한다.

1. 회귀(Regression) 모델 평가

핵심 질문

회귀 문제에서의 핵심 질문은 다음과 같다.

예측값은 실제값과 얼마나 가까운가? 즉, 오차(error)의 크기를 어떻게 정의하고, 어떻게 평균낼 것인가?

회귀 모델은 연속적인 실수값(real-valued output)을 예측한다. 따라서 분류 문제처럼 “맞다 / 틀리다”로 평가할 수 없으며,

• 오차의 크기
• 오차의 분포
• 큰 오차를 얼마나 강하게 벌줄 것인지

를 명확히 정의해야 한다.

1.1 MAE (Mean Absolute Error, 평균 절대 오차)

MAE는 가장 직관적인 회귀 오차 지표다. 각 데이터 포인트에서 발생한 오차의 절대값을 취한 뒤, 이를 평균낸다.

$$ MAE = \frac{1}{n} \sum_{i=1}^{n} |y_i - \hat{y}_i| $$

절대값을 사용하는 이유는 평가 과정에서 과대 예측과 과소 예측의 방향보다는 오차의 크기 자체가 중요하기 때문이다.

특성 및 해석

• 모든 오차를 선형적으로 취급한다.
• 오차 10은 오차 5의 정확히 두 배로 반영된다.
• 일부 이상치(outlier)가 존재하더라도 지표가 급격히 커지지 않는다.
• 데이터 단위와 동일하므로 해석이 용이하다.

예를 들어, 집값 예측에서 MAE가 100이라면 모델은 평균적으로 약 100만 원 정도의 오차를 가진다고 해석할 수 있다.

사용이 적합한 경우

• “평균적으로 얼마나 틀리는지”를 파악하고자 할 때
• 예측 오차의 단위 자체가 해석의 대상이 되는 경우
• 일부 이상치는 존재하지만, 이를 과도하게 강조할 필요가 없는 문제

사용이 부적절한 경우

• 큰 오차가 발생했을 때의 비용이 매우 큰 문제
• 극단적인 예측 실패를 반드시 억제해야 하는 경우

이러한 상황에서는 MAE가 큰 오차의 위험성을 충분히 반영하지 못할 수 있다.

1.2 MSE / RMSE (Mean Squared Error)

MSE는 오차를 제곱한 뒤 평균낸 값이며, RMSE는 MSE에 제곱근을 취해 원래 데이터 단위로 복원한 지표다.

$$ MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 $$

$$ RMSE = \sqrt{MSE} $$

오차를 제곱함으로써, 큰 오차는 작은 오차보다 훨씬 큰 패널티를 받는다.

왜 제곱을 사용하는가?

오차 제곱은 다음과 같은 효과를 만든다.

• 작은 오차는 상대적으로 영향이 작다.
• 큰 오차는 제곱으로 인해 급격히 커진다.

즉, MSE/RMSE는 “큰 실수는 반드시 강하게 벌주겠다”는 명확한 의도를 가진 지표다.

MAE와의 근본적인 차이

실무에서는 해석의 편의성 때문에 RMSE가 MSE보다 더 자주 사용된다.

사용이 적합한 경우

• 큰 예측 오차가 실제 비용 또는 위험으로 직결되는 경우
• 일부 시점의 실패가 시스템 전체에 영향을 미치는 문제 (전력 수요 예측, 트래픽 예측, 설비 부하 예측 등)

사용이 부적절한 경우

• 데이터에 노이즈나 이상치가 많이 포함된 경우
• 소수의 비정상 샘플이 전체 성능 평가를 왜곡해서는 안 되는 경우

1.3 MAPE (Mean Absolute Percentage Error)

MAPE는 오차를 실제값 대비 비율로 표현하는 지표다.

$$ MAPE = \frac{100%}{n} \sum_{i=1}^{n} \left| \frac{y_i - \hat{y}_i}{y_i} \right| $$

절대 오차는 데이터의 스케일에 크게 의존한다. MAPE는 이를 보완하기 위해 비율 기반 평가를 사용한다.

특성 및 장점

• 서로 다른 스케일의 데이터 간 성능 비교가 가능하다.
• 비즈니스 보고에 직관적이다.
• “평균적으로 8% 정도의 오차가 발생한다”와 같은 설명이 가능하다.

사용이 적합한 경우

• 국가·지점·제품군 등 규모가 다른 대상 간 성능 비교
• 실제값이 0이 되지 않는 매출, 수요, 트래픽 데이터
• 비즈니스 의사결정 보고용 지표가 필요한 경우

사용이 부적절한 경우

• 실제값이 0이 될 수 있는 데이터
• 실제값이 매우 작은 구간이 자주 등장하는 경우

이 경우 MAPE는 정의되지 않거나 비현실적으로 큰 값을 가질 수 있다.

1.4 (R^2) Score 및 Adjusted (R^2)

(R^2)는 오차 기반 지표가 아니라, 모델이 종속 변수의 전체 분산을 얼마나 설명하는지를 측정한다.

$$R^2 = 1 - \frac{SSE}{SST}$$

• SSE: 잔차 제곱합
• SST: 전체 제곱합

해석

• (R^2 = 1): 완벽한 예측
• (R^2 = 0): 평균 예측과 동일
• 음수 가능: 평균보다 못한 모델

치명적인 한계

독립변수(X)를 추가하면, 그 변수가 의미가 없더라도 SSE는 감소할 가능성이 크다. 따라서 (R^2)는 거의 항상 증가한다.

즉, 모델의 복잡도를 전혀 고려하지 않는다.

Adjusted (R^2)

이를 보완하기 위해 변수 개수와 샘플 수를 고려한 지표가 Adjusted (R^2)다.

$$R^2_{adj} = 1 - (1 - R^2)\frac{n-1}{n-k-1}$$

• (n): 샘플 수
• (k): 독립변수 개수

불필요한 변수가 추가되면 패널티가 부여된다.

사용이 적합한 경우

• 선형 회귀 및 다중 회귀 모델 비교
• 설명력과 해석 가능성이 중요한 분석 과제

사용이 부적절한 경우

• 비선형 머신러닝 모델의 단독 성능 평가
• 예측 정확도가 핵심 목표인 문제

2. 분류(Classification) 모델 평가

핵심 질문

분류 문제에서는 다음 두 질문이 중요하다.

• 얼마나 정확히 구분하는가?
• 어떤 종류의 실수를 하는가?

특히 클래스 불균형이 존재하는 경우, Accuracy 하나만으로는 모델 성능을 평가할 수 없다.

2.1 혼동 행렬 (Confusion Matrix)

모든 분류 지표는 혼동 행렬에서 출발한다.

• FP: 1종 오류 (오진)
• FN: 2종 오류 (놓침)

2.2 Precision과 Recall

Precision (정밀도)

$$ Precision = \frac{TP}{TP + FP} $$

양성이라고 예측한 것 중, 실제로 맞은 비율이다. FP를 줄이는 것이 핵심이다.

적합한 사례:

• 스팸 필터링
• 추천 시스템
• 자동 차단 시스템

Recall (재현율)

$$Recall = \frac{TP}{TP + FN}$$

실제 양성 중에서 모델이 찾아낸 비율이다. FN을 줄이는 것이 핵심이다.

적합한 사례:

• 암 진단
• 사기 탐지
• 결함 검출

2.3 F1-score

Precision과 Recall의 조화 평균이다.

$$F1 = 2 \cdot \frac{Precision \cdot Recall}{Precision + Recall}$$

두 지표 중 하나라도 낮으면 F1-score도 낮아진다. 불균형 데이터에서 Accuracy를 대체하는 대표적인 지표다.

2.4 Log Loss (Cross-Entropy Loss)

Log Loss는 정답 여부가 아니라, 모델이 예측한 확률의 품질을 평가한다.

$$ -\frac{1}{N} \sum (y \log(p) + (1-y)\log(1-p)) $$

틀렸을 뿐 아니라, 틀린 예측에 강한 확신을 가질수록 큰 패널티를 받는다.

확률 기반 의사결정 시스템에서 핵심적인 지표다.

2.5 ROC-AUC

ROC-AUC는 임계값에 독립적인 성능 지표다. 순위 기반으로 모델의 분류 능력을 평가한다.

“임의의 양성 샘플이 음성 샘플보다 높은 점수를 받을 확률”로 해석할 수 있다.

한눈에 보는 요약 (Cheat Sheet)

Quiz

📌 퀴즈 1. 집값 예측 모델

어떤 모델이 집값(단위: 만 원)을 예측하고 있다. 데이터에는 고가 주택이 일부 섞여 있어 아주 큰 오차가 간혹 발생한다. 비즈니스 담당자는

“평균적으로 얼마나 틀리는지만 알면 된다” 고 말한다.

Q. 이 상황에서 가장 적절한 평가 지표는 무엇인가?

📌 퀴즈 2. 전력 수요 예측

전력 사용량을 예측하는 모델을 만들었다. 갑작스러운 폭염·한파 시 예측이 크게 빗나가는 경우가 있으며, 운영팀은 다음과 같이 요구한다.

“큰 예측 실패는 절대 용납할 수 없다.”

Q. 이 요구사항을 가장 잘 반영하는 회귀 평가 지표는 무엇인가?

📌 퀴즈 3. 글로벌 매출 예측 비교

A 국가의 매출은 수백만 원 단위, B 국가는 수천억 원 단위다. 두 나라의 예측 모델 성능을 같은 기준으로 비교해야 한다.

Q. 이 경우 가장 적절한 회귀 평가 지표는 무엇인가?

📌 퀴즈 4. 스팸 메일 필터링

스팸 메일 분류 모델을 운영 중이다. 스팸 메일 몇 개를 놓치는 것보다 정상 메일을 스팸으로 분류하는 것이 훨씬 치명적이다.

Q. 이 상황에서 가장 우선적으로 봐야 할 분류 평가 지표는 무엇인가?

📌 퀴즈 5. 암 진단 모델

암 진단 보조 모델을 개발 중이다. 의사는 다음과 같이 말한다.

“암 환자를 정상으로 분류하는 일만은 절대 없어야 한다.”

데이터는 정상 환자가 훨씬 많은 불균형 데이터다.

Q. 이 상황에서 가장 중요한 평가 지표는 무엇인가? (정확도는 적절한 지표일까?)

• 병렬화가 어렵다
• 시퀀스가 길어질수록 비효율적이다

이 문제를 해결하려는 방향에서 다음과 같은 시계열 모델들이 등장한다.

1. 1D CNN (Convolutional Neural Network for Time Series)

핵심 개념

시간 축 위에서 패턴을 “국소적으로” 훑는다

• 이미지의 가로·세로 대신
• 시간 축 하나만 놓고 컨볼루션

짧은 구간의 패턴을 반복적으로 감지한다.

시계열을 어떻게 보나?

• 시계열 = 1차원 신호
• 커널 = 짧은 시간 패턴 탐지기

예:

• 급격한 상승
• 특정 파형
• 반복되는 로컬 패턴

언제 쓰는가?

• 국소 패턴이 중요할 때
• 전체 순서보다는 형태(shape) 가 중요할 때
• 시계열 길이가 길고 빠른 학습이 필요할 때

예:

• 센서 신호
• 진동 데이터
• 음성 파형
• 설비 이상 감지

2. TCN (Temporal Convolutional Network)

TCN은 시계열 전용으로 설계된 CNN이라고 보면 된다.

핵심 개념

CNN으로 RNN의 역할을 대체하자

TCN은 다음 두 가지를 결합한다.

• Causal Convolution → 미래를 보지 않음
• Dilated Convolution → 적은 층으로 긴 과거를 커버

시계열을 어떻게 보나?

• 순서를 지키면서
• 점점 더 넓은 과거를 컨볼루션으로 본다

즉,

RNN처럼 과거를 누적하지만 순차 계산은 하지 않는다

언제 쓰는가?

• 중·장기 의존성이 필요한 시계열
• RNN의 순차 계산이 느릴 때
• 병렬 학습이 중요한 환경

예:

• 시계열 예측
• 로그 분석
• 제어 시스템
• 산업 데이터

3. Transformer

Transformer는 시계열뿐 아니라 자연어 처리 전반의 패러다임을 바꾼 모델이다.

핵심 개념

모든 시점을 동시에 보고, 중요한 것만 선택한다

• 순차 처리 없음
• 모든 시점 간의 관계를 한 번에 계산
• 중요도는 Attention 으로 결정

시계열을 어떻게 보나?

• 시계열 = 토큰 시퀀스
• 각 시점은 서로를 직접 참조 가능
• 거리와 상관없이 관계를 학습

즉,

“얼마나 오래됐는지”보다 “얼마나 중요한지”가 더 중요하다

언제 쓰는가?

• 아주 긴 시계열
• 복잡한 전역 패턴
• 다변량 시계열
• 충분한 데이터와 연산 자원 존재

예:

• 장기 예측
• 멀티 센서 시계열
• 복잡한 상호작용이 있는 데이터

• 시계열 → 특징(feature) 추출
• 고정 길이 벡터 → 회귀 문제
• 시간 의존성은 간접적으로만 존재

RNN 계열 모델은 이 접근에 대한 명확한 문제의식에서 출발한다.

“왜 시간 정보를 사람이 요약해야 하는가?” “순서 자체를 모델이 직접 다루게 할 수는 없는가?”

그 결과가 RNN, 그리고 그 한계를 보완한 LSTM과 GRU다.

1. RNN (Recurrent Neural Network)

기본 아이디어

RNN은 이전 시점의 상태를 다음 시점으로 전달한다.

$$[ h_t = \phi(W_x x_t + W_h h_{t-1} + b) ]$$ $$[ y_t = W_y h_t ]$$

• (x_t): 시점 (t)의 입력
• (h_t): 은닉 상태(hidden state)
• (h_{t-1}): 과거 정보를 압축한 벡터

과거 정보가 하나의 상태 벡터로 누적된다

RNN이 시계열을 다루는 방식

• 시계열 전체를 한 스텝씩 순차 처리
• 과거 → 은닉 상태에 압축
• 피처 추출을 사람이 아닌 모델이 수행

이는 슬라이딩 윈도우 + 회귀와 근본적으로 다르다.

한계: Gradient Vanishing / Exploding

RNN은 학습 시 역전파(BPTT) 를 사용한다. 이때 다음 문제가 발생한다.

• 긴 시퀀스에서 기울기 소실
• 먼 과거 정보가 학습되지 않음

결과적으로,

RNN은 이론적으로는 시계열을 기억하지만 실제로는 짧은 기억만 가능하다

2. LSTM (Long Short-Term Memory)

RNN의 한계를 해결하기 위해 등장한 구조다. 핵심은 기억을 선택적으로 저장하고 삭제하는 메커니즘이다.

LSTM의 핵심 구성 요소

LSTM은 두 개의 상태를 가진다.

• Cell State ((c_t)): 장기 기억
• Hidden State ((h_t)): 단기 출력

그리고 이를 제어하는 게이트(gate) 가 있다.

게이트 구조

Forget Gate

$$[ f_t = \sigma(W_f [h_{t-1}, x_t]) ]$$

• 무엇을 잊을지 결정

Input Gate

$$[ i_t = \sigma(W_i [h_{t-1}, x_t]) ]$$ $$[ \tilde{c}t = \tanh(W_c [h{t-1}, x_t]) ]$$

• 무엇을 새로 기억할지 결정

Cell Update

$$[ c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t ]$$

Output Gate

$$[ o_t = \sigma(W_o [h_{t-1}, x_t]) ]$$ $$[ h_t = o_t \odot \tanh(c_t) ]$$

LSTM 정리

• 기울기 소실 문제 완화
• 장기 의존성 학습 가능
• 불규칙한 시계열에서도 안정적
• 단, 구조가 복잡하고 연산량이 크다.

3 GRU (Gated Recurrent Unit)

GRU는 LSTM의 단순화 버전이다.

GRU 구조

GRU는 하나의 상태만 유지한다.

$$[ z_t = \sigma(W_z [h_{t-1}, x_t]) \quad \text{(update gate)} ]$$ $$[ r_t = \sigma(W_r [h_{t-1}, x_t]) \quad \text{(reset gate)} ]$$

$$[ \tilde{h}t = \tanh(W [r_t \odot h{t-1}, x_t]) ]$$

$$[ h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t ]$$

GRU의 특징

• LSTM보다 파라미터 적음
• 학습 속도 빠름
• 성능은 많은 경우 LSTM과 유사

4. RNN / LSTM / GRU 비교 도표

5. 언제 어떤 모델을 사용하는가

RNN을 쓰는 경우

• 시퀀스 길이가 매우 짧을 때

LSTM을 쓰는 경우

• 장기 패턴이 명확한 시계열
• 불규칙한 간격, 누락 데이터 존재
• 시계열 길이가 길고 복잡한 경우

예:

• 설비 로그
• 사용자 행동 시퀀스
• 금융 시계열

GRU를 쓰는 경우

• LSTM이 과도하게 무거운 경우
• 데이터가 상대적으로 적을 때
• 빠른 실험이 필요한 경우

• 입력 샘플들은 서로 독립(i.i.d.)
• 각 샘플은 고정 길이의 벡터
• 순서 정보는 구조적으로 존재하지 않음

이 가정은 시계열 데이터와 정면으로 충돌한다. 따라서 머신러닝에서 시계열을 사용하려면, 시계열의 “시간적 구조”를 직접 모델에 맡기지 않는다.

대신,

시계열의 성질을 사람이 해석 가능한 특징으로 추출한 뒤 이를 일반 회귀 문제로 변환한다.

시계열 → 고정 길이 벡터로의 변환

시계열 ( {y_t} ) 는 길이가 가변적이고 순서 의존적이다. 머신러닝에 입력하려면 다음 조건을 만족해야 한다.

• 길이가 고정된 벡터
• 각 시점이 하나의 샘플

이를 위해 윈도우 기반 특징 추출(window-based feature extraction) 을 사용한다.

$$[ X_t = g(y_{t-k}, \dots, y_{t-1}) ]$$

• $$(g(\cdot))$$: 특징 추출 함수
• 출력은 고정 차원의 벡터

통계적 특징

• 이동 평균 $$[ \mu_t = \frac{1}{k}\sum_{i=1}^{k} y_{t-i} ]$$

• 이동 분산 / 표준편차

• 최소값, 최대값

• 분위수(quantile)

변화량 기반 특징

차분 기반 특징

$$[ \Delta y_{t-1} = y_{t-1} - y_{t-2} ]$$

비율 / 증가율

$$[ \frac{y_{t-1} - y_{t-2}}{y_{t-2}} ]$$

이는 추세 방향성과 속도를 표현한다.

• 상승 / 하강 국면
• 급격한 변화 감지

회귀 모델에서의 시계열

최종적으로 위에 설명한 내용을 수식으로 쓰면 아래와 같이 나타낼 수 있다.

$$y_t = f(X_t)$$

• $$X_t$$: 시계열에서 추출된 특징 벡터

• $$f$$: 일반 회귀 모델

  • Linear / Ridge / Lasso
  • Random Forest
  • XGBoost / LightGBM
  • MLP

장점

• 모델 선택이 자유롭다
• 해석 가능한 피처 설계 가능
• 데이터가 적어도 적용 가능
• 학습이 안정적

한계

• 장기 의존성은 직접 표현 불가
  • 윈도우 크기에 의존
  • 멀리 있는 과거는 요약되거나 삭제됨
• 피처 설계에 과도하게 의존
  • 사람이 무엇을 추출하느냐가 성능을 좌우
  • 도메인 지식 필요
• “순서”는 간접적으로만 존재
  • 모델은 시간을 이해하지 않음
  • 시간은 통계량으로 요약됨

Part 1. Feature Selection의 본질

1.1 정의

Feature Selection은 주어진 입력 변수 집합 $X = {x_1, x_2, \dots, x_p}$ 중에서 예측 목표 $y$에 유의미한 일부 $S \subseteq X$를 선택하는 과정이다.

이는 새로운 변수를 생성하는 Feature Engineering과 구분된다.

• Feature Selection: $X \rightarrow S \subseteq X$
• Feature Engineering: $X \rightarrow X'$ (차원, 의미 변경)

1.2 왜 필요한가

1. 차원의 저주 (Curse of Dimensionality) 차원 $p$가 증가할수록 샘플 공간의 부피는 지수적으로 증가한다. 모델은 제한된 샘플로 고차원 공간을 일반화해야 하므로 분산이 급격히 증가한다.

2. 분산 증가 (Variance Inflation) 선형 회귀에서 추정 분산은 다음과 같이 표현된다.

$$ \mathrm{Var}(\hat{\beta}) = \sigma^2 (X^TX)^{-1} $$

불필요하거나 상관된 feature가 많아질수록 $X^TX$는 ill-conditioned가 되며, 추정치 분산이 커진다.

3. 해석 가능성 모델이 사용하는 변수의 수가 줄어들수록 각 변수의 역할을 설명할 수 있다.

Part 2. Filter Method

2.1 개념

Filter Method는 모델과 독립적으로 feature와 target 사이의 통계적 관계만을 이용해 변수를 선택한다.

핵심 가정:

좋은 feature는 target과 개별적으로도 강한 연관성을 가진다.

2.2 주요 기법

2.2.1 분산 기반 선택 (Variance Threshold)

분산이 0 또는 매우 작은 feature는 모든 샘플에서 거의 동일한 값을 가지므로 정보량이 적다.

$$ \mathrm{Var}(x_j) = \frac{1}{n}\sum_{i=1}^n (x_{ij}-\bar{x}_j)^2 $$

임계값 $\tau$보다 작은 feature는 제거한다.

한계:

• target과의 관계를 전혀 고려하지 않는다.

2.2.2 상관계수 기반 선택

연속형 변수에서 Pearson 상관계수:

$$ \rho(x_j, y) = \frac{\mathrm{Cov}(x_j,y)}{\sigma_{x_j}\sigma_y} $$

$|\rho|$가 큰 feature를 선택한다.

주의점:

• 비선형 관계를 포착하지 못함
• 다중공선성 문제 미해결

2.2.3 통계적 가설 검정

• 회귀: t-test, F-test
• 분류: Chi-square test

귀무가설 $H_0$: feature와 target은 독립이다.

p-value가 작을수록 해당 feature는 target과 유의미한 관계를 가진다.

Part 3. Wrapper Method

3.1 개념

Wrapper Method는 feature subset을 직접 모델에 적용하여 성능을 기준으로 선택한다.

$$ S^* = \arg\max_{S \subseteq X} \mathrm{Score}(f_S) $$

여기서 $f_S$는 subset $S$로 학습한 모델이다.

3.2 알고리즘

3.2.1 Forward Selection

1. $S = \emptyset$
2. 모든 $x_j \notin S$에 대해 $S \cup {x_j}$ 평가
3. 성능 최대 feature 추가
4. 개선이 없을 때 종료

복잡도:

• $O(p^2)$ 수준

3.2.2 Backward Elimination

1. $S = X$
2. 하나씩 제거하며 성능 평가
3. 성능 저하 최소 feature 제거

전제:

• 초기 모델 학습 가능해야 함

3.2.3 RFE (Recursive Feature Elimination)

모델의 feature 중요도를 이용해 반복적으로 제거한다.

선형 모델 기준:

$$ \text{importance}(x_j) = |\hat{\beta}_j| $$

Part 4. Embedded Method

4.1 개념

Embedded Method는 모델 학습 과정 내부에 feature 선택이 포함된다.

4.2 L1 정규화 (Lasso)

목적 함수:

$$ \min_{\beta} |y - X\beta|_2^2 + \lambda |\beta|_1 $$

$L_1$ penalty는 계수를 정확히 0으로 만들 수 있다.

기하학적 해석 없이 보면:

• 절댓값 패널티 → 작은 계수는 비용 대비 이득이 없어 제거됨

4.3 Tree 기반 모델

Decision Tree, Random Forest, Gradient Boosting은 분할 과정에서 feature를 선택한다.

불순도 감소 기준:

$$ \Delta I = I(parent) - \sum_k \frac{n_k}{n} I(child_k) $$

중요한 feature는 더 자주, 더 큰 불순도 감소를 만든다.

주의:

• 제거가 아닌 "사용 빈도" 기반
• 고유값 많은 feature 편향

Part 5. 실무 적용 전략

1. Variance / Correlation Filter로 1차 제거
2. L1 또는 Tree 기반 Embedded로 압축
3. 필요 시 Wrapper로 미세 조정

Feature Selection은 정확도를 올리는 기법이 아니라, 일반화와 해석을 통제하는 기법이다.

— 일반 스케일링과 무엇이 다른가

시계열 데이터에서 스케일링은 단순히 값의 크기를 맞추는 문제가 아니다.

시간 흐름을 보존하면서 미래 정보를 사용하지 않는 것이 핵심이다.

1. 시계열 스케일링의 핵심 제약 조건

1.1 데이터 누수(Data Leakage) 방지

시계열 데이터는 다음이 절대 금지다.

❌ 전체 기간 평균 / 표준편차로 스케일링

이 경우,

• 미래 시점의 통계량이 과거 학습에 사용된다

이는 모델 성능을 비현실적으로 부풀린다.

1.2 올바른 기준

시계열 스케일링은 반드시 다음을 따른다.

1. Train 구간에서만 통계량 계산
2. Validation / Test에 동일 적용
3. 시간 순서 유지

2. 시계열 데이터에 적합한 스케일링 방법

2.1 Standard Scaling (가장 일반적인 선택)

언제 좋은가

• 값의 분포가 비교적 안정적
• 급격한 스케일 변화 없음
• 딥러닝 모델 사용 (LSTM, GRU, Transformer)

장점

• 학습 안정성 우수
• 경사하강 수렴 속도 개선
• 대부분의 시계열 NN과 궁합이 좋음

주의점

• 이상치에 민감
• Drift가 심한 경우 성능 저하 가능

2.2 Min-Max Scaling (범위 제한이 필요한 경우)

언제 좋은가

• 입력 범위가 명확히 제한된 모델
• activation 함수가 민감한 경우
• CNN 기반 시계열 모델

주의점

• 이상치에 매우 취약
• 미래에 새로운 max/min 등장 가능
• Test 구간에서 범위 초과 발생 가능

2.3 Robust Scaling (이상치가 많은 시계열)

언제 좋은가

• 센서 데이터
• 산업 장비 로그
• 간헐적인 스파이크 존재

장점

• 중앙값 기준
• IQR 기반 → 극단값 영향 최소화
• 이상치 제거가 어려운 경우 대안

2.4 Log 변환 + Scaling (강력한 조합)

시계열 데이터는 분포가 심하게 치우친 경우가 많다.

이 경우 추천되는 흐름은 다음이다.

Log Transform → Standard / Robust Scaling

효과

• 분산 안정화
• 급격한 스케일 변화 완화
• 학습 안정성 증가

3. 시계열 모델별 스케일링 권장 사항

※ 트리 계열은 필수는 아니지만 입력 분산 안정 목적이라면 적용 가능

4. 시계열 전용 스케일링 전략 (고급)

4.1 Window-based Scaling

• 슬라이딩 윈도우마다 스케일 재계산
• 온라인 예측
• Drift 대응 가능

[t-n, t-1] 구간 기준 scaling → t 예측

단점:

• 구현 난이도 높음
• 재현성 관리 어려움

4.2 Feature별 스케일링 분리

• 원본 값
• Lag 값
• Rolling 값

각각 다른 스케일링 적용 가능

5. 시계열 스케일링에서 자주 발생하는 실수

1. 전체 기간 기준 scaling
2. Test 데이터로 scaler 재학습
3. Lag 생성 후 scaling 순서 오류
4. 이상치 고려 없이 Min-Max 적용
5. 변수별 스케일링 불일치

6. 권장 전처리 순서 (시계열)

Resampling
→ 결측치 처리
→ 이상치 처리
→ 분포 변환 (선택)
→ Lag / Rolling Feature 생성
→ Scaling (Train 기준)

1.1 비시계열 데이터란 무엇인가

비시계열 데이터는 각 관측값(행)이 시간 순서에 의존하지 않는 데이터를 의미한다.

대표적인 예시는 다음과 같다.

• 고객 정보 테이블
• 실험 결과 데이터
• 설문조사 데이터
• 정적인 특성 기반 데이터셋

이러한 데이터는 일반적으로 행 단위 분석을 전제로 한다.

1.2 핵심 가정: i.i.d.

비시계열 데이터 분석은 다음 가정을 암묵적으로 포함한다.

• Independent: 각 샘플은 서로 독립
• Identically Distributed: 동일한 분포에서 생성됨

이 가정이 성립하기 때문에 다음이 가능해진다.

• 행 순서 무시
• 랜덤 셔플
• 통계량의 전역적 계산

이 점이 시계열 데이터와의 가장 큰 차이다.

2. 비시계열 데이터 전처리의 목적

2.1 목적의 재정의

비시계열 데이터 전처리의 목적은 다음과 같다.

데이터의 통계적 특성과 표현 방식을 모델의 가정과 계산 구조에 맞게 변환하는 것

즉,

• 정보를 유지하면서
• 불필요한 변동을 줄이고
• 모델이 학습하기 쉬운 형태로 바꾼다

2.2 전처리의 주요 대상

1. 결측치 (Missing Values)
2. 이상치 (Outliers)
3. 스케일 (Scale)
4. 분포 (Distribution)
5. 범주형 변수 (Categorical Variables)
6. 특성 간 관계 (Feature Relationships)

3. 결측치 처리 (Missing Value Handling)

3.1 결측치의 유형

비시계열 데이터에서 결측치는 다음 세 가지로 구분된다.

1. MCAR (Missing Completely At Random)
2. MAR (Missing At Random)
3. MNAR (Missing Not At Random)

이 구분은 처리 전략 선택의 근거가 된다.

3.2 단순 삭제 (Listwise Deletion)

df = df.dropna()

언제 가능한가

• MCAR 가정이 성립
• 결측 비율이 매우 낮음
• 데이터가 충분히 많음

문제점

• 데이터 손실
• 분포 왜곡 가능성

3.3 단순 대체 (Imputation)

평균 / 중앙값 대체

df['age'] = df['age'].fillna(df['age'].median())

• 평균: 정규 분포에 적합
• 중앙값: 이상치에 강건

이 방법은 분산을 인위적으로 줄인다는 한계가 있다.

3.4 조건부 대체

• 그룹별 평균
• 카테고리별 중앙값

df['income'] = df.groupby('job')['income'].transform(
    lambda x: x.fillna(x.median())
)

결측이 다른 변수와 관련되어 있을 때 유리하다.

3.5 모델 기반 대체

• KNN Imputation
• Regression Imputation

이 방법은 정보 손실을 줄이지만,

• 계산 비용 증가
• 과적합 위험

이 존재한다.

4. 이상치 처리 (Outlier Handling)

4.1 비시계열 이상치의 정의

비시계열 데이터에서 이상치는 전체 분포 기준에서 극단적인 값이다.

시간 맥락은 고려하지 않는다.

4.2 통계적 탐지 방법

Z-score

z = (df['x'] - df['x'].mean()) / df['x'].std()
df = df[abs(z) < 3]

정규 분포 가정이 암묵적으로 포함된다.

IQR

Q1 = df['x'].quantile(0.25)
Q3 = df['x'].quantile(0.75)

• 분포 가정이 약함
• 실무에서 가장 많이 사용

4.3 이상치 처리 전략

• 제거
• 클리핑
• 로그 변환
• 별도 플래그 변수 생성

모델과 목적에 따라 선택해야 한다.

5. 스케일링 (Feature Scaling)

5.1 왜 스케일링이 필요한가

많은 모델은 변수의 절대 크기에 민감하다.

• 거리 기반 모델 (KNN, K-Means)
• 경사하강 기반 모델 (Linear/Logistic Regression, NN)

5.2 대표적인 스케일링 방법

Standardization

(x - mean) / std

• 평균 0, 분산 1
• 정규 분포 가정

Min-Max Scaling

(x - min) / (max - min)

• [0, 1] 범위
• 이상치에 민감

Robust Scaling

• 중앙값 기준
• IQR 사용
• 이상치에 강건

6. 분포 변환 (Distribution Transformation)

6.1 왜 분포가 중요한가

많은 통계 모델은 입력 변수의 분포에 대한 가정을 포함한다.

• 선형 회귀: 잔차 정규성
• 통계 검정: 정규성 가정

6.2 로그 변환

df['x_log'] = np.log1p(df['x'])

• 양의 치우친 분포 완화
• 분산 안정화

6.3 Box-Cox / Yeo-Johnson

• 자동 분포 정규화
• 모델 기반 전처리에 유리

7. 범주형 변수 처리 (Categorical Encoding)

7.1 범주형 변수의 문제점

대부분의 모델은 문자형 데이터를 직접 처리하지 못한다.

7.2 One-Hot Encoding

pd.get_dummies(df['category'])

• 단순
• 차원 폭발 위험

7.3 Ordinal Encoding

• 순서가 있는 범주에만 사용
• 잘못 쓰면 심각한 왜곡 발생

7.4 Target Encoding

• 평균 타깃값으로 치환
• 데이터 누수 위험
• 반드시 Train 기준 적용

8. 특성 선택과 차원 축소

8.1 불필요한 특성의 문제

• 노이즈 증가
• 과적합
• 해석력 저하

8.2 Filter / Wrapper / Embedded 방법

• 통계 기반
• 모델 기반
• 정규화 기반

8.3 PCA

• 상관된 변수 압축
• 해석력 감소
• 거리 기반 모델에서 효과적

9. 비시계열 데이터 전처리 흐름 요약

1. 데이터 이해 및 분포 확인
2. 결측치 유형 판단
3. 이상치 탐지 및 처리
4. 스케일 및 분포 변환
5. 범주형 인코딩
6. 특성 선택 / 차원 축소
7. 데이터 분리 및 누수 방지

1. 시계열 데이터의 정의와 특성

1.1 시계열 데이터란 무엇인가

시계열 데이터(Time Series Data)는 시간의 흐름에 따라 순차적으로 관측된 데이터를 의미한다.

수학적으로는 시간 ( t )에 대해 정의된 확률 변수 ( X_t )의 집합으로 표현된다.

이 정의에서 중요한 점은 다음 두 가지다.

1. 각 관측값은 확률 변수이다
2. 관측값들은 서로 독립적이지 않다

1.2 일반 데이터와의 차이점

일반적인 머신러닝 데이터는 다음 가정을 암묵적으로 가진다.

• 각 샘플은 독립적이다 (i.i.d.)
• 행의 순서는 의미가 없다

시계열 데이터는 이 가정을 모두 위반한다.

• 시간 순서가 의미를 가진다
• 과거 값이 현재 값에 영향을 준다
• 데이터 분포가 시간에 따라 변할 수 있다

따라서 시계열 데이터는 별도의 전처리와 분석 체계가 필요하다.

2. 시계열 전처리의 목적

2.1 전처리의 재정의

시계열 전처리는 단순히 데이터를 깨끗하게 만드는 작업이 아니다.

시계열 전처리의 목적은 다음과 같다.

시간 구조를 유지한 채 데이터 생성 과정을 단순한 통계적 구조로 변환하여 모델이 학습 가능한 형태로 만드는 것

2.2 시계열 전처리의 핵심 원칙

1. 시간 순서를 절대 훼손하지 않는다
2. 결측과 이상을 삭제가 아닌 해석의 대상으로 본다
3. 통계적 성질을 확인한 뒤 피처를 설계한다

3. 시간 인덱스와 샘플링 구조

3.1 시간 인덱스의 역할

시계열 데이터에서 시간 인덱스는 단순한 컬럼이 아니라 좌표계에 해당한다.

df = df.sort_index()

이 작업은 모든 시계열 분석의 전제 조건이다.

3.2 불규칙 샘플링 문제

현실 데이터에서는 다음과 같은 상황이 빈번하다.

• 기록 누락
• 이벤트 기반 수집
• 센서 지연

이 경우 모델은 실제 현상이 아니라 샘플링 간격의 불규칙성을 학습하게 된다.

이를 해결하기 위해 시간 단위를 명시적으로 통일해야 한다.

4. Resampling (리샘플링)

4.1 Resampling의 정의

Resampling은 시간 단위를 기준으로 데이터를 재집계하는 과정이다.

df = df.resample("1H").mean()

4.2 다운샘플링과 업샘플링

다운샘플링

• 짧은 간격 → 긴 간격
• 노이즈 감소
• 장기 추세 강조

업샘플링

• 긴 간격 → 짧은 간격
• 결측치 증가
• 보간 필수

Resampling은 항상 결측치 처리 전략과 함께 설계되어야 한다.

5. 시계열 결측치 처리

5.1 시계열에서 결측의 의미

시계열에서 결측은 “값이 0”이 아니라 해당 시점에 관측이 이루어지지 않았음을 의미한다.

따라서 단순 삭제는 시간 구조를 붕괴시킨다.

5.2 선형 보간 (Linear Interpolation)

df['value'] = df['value'].interpolate(method='linear')

• 연속적인 변화 가정
• 짧은 결측 구간에 적합
• 물리량 데이터에 자주 사용

5.3 이전 값 채우기 (Forward Fill)

df['value'] = df['value'].ffill()

• 상태 유지 가정
• 설정 값, 장비 모드에 적합
• 장기 결측 시 왜곡 가능

6. 이상치 처리

6.1 시계열 이상치의 특성

시계열 이상치는 다음 중 하나일 수 있다.

• 측정 오류
• 시스템 상태 변화
• 실제 이벤트 발생

따라서 이상치는 무조건 제거 대상이 아니다.

6.2 통계적 방법의 한계

IQR, z-score는 시간 순서를 고려하지 않는다.

실무에서는 이상치를 제거하기보다 이상치 여부를 피처로 활용하는 경우가 많다.

7. 정상성 (Stationarity)

7.1 정상성의 정의

정상성이란 시계열의 통계적 성질이 시간에 따라 변하지 않는 상태를 의미한다.

• 평균 일정
• 분산 일정
• 자기상관 구조 일정

7.2 정상성의 중요성

• 대부분의 시계열 모델은 정상성 가정
• 비정상 시계열은 예측 불안정
• 과거 데이터가 미래를 설명하지 못함

7.3 정상성 검정 (ADF Test)

from statsmodels.tsa.stattools import adfuller
adfuller(df['value'])[1]

• p-value < 0.05 → 정상
• p-value ≥ 0.05 → 비정상

8. 차분 (Differencing)

8.1 차분의 의미

차분은 시계열을 값의 문제에서 변화량의 문제로 변환한다.

df['diff'] = df['value'].diff()

8.2 차분의 효과

• 추세 제거
• 정상성 확보
• 자기상관 구조 단순화

9. 추세와 계절성 분해

9.1 시계열 구성 요소

시계열은 일반적으로 다음으로 구성된다.

• 추세 (Trend)
• 계절성 (Seasonality)
• 불규칙 성분 (Residual)

9.2 시계열 분해

from statsmodels.tsa.seasonal import seasonal_decompose
seasonal_decompose(df['value'], period=24)

이를 통해 시계열 구조를 시각적으로 확인할 수 있다.

10. 자기상관 분석

10.1 자기상관의 개념

자기상관은 현재 값과 과거 값 사이의 상관 관계다.

10.2 ACF / PACF

• ACF: 전체 자기상관 구조
• PACF: 순수한 lag 영향

이는 Lag Feature 설계의 기준이 된다.

11. Lag 및 Rolling Feature

11.1 Lag Feature

df['lag_1'] = df['value'].shift(1)

과거 정보를 명시적 입력 변수로 변환한다.

11.2 Rolling Feature

df['rolling_mean'] = df['value'].rolling(7).mean()

최근 구간의 상태를 요약한다.

12. 정리

이 장에서 다룬 시계열 전처리는 다음 흐름으로 정리된다.

1. 시간 인덱스 정렬
2. Resampling
3. 결측치 처리
4. 이상치 해석
5. 정상성 진단
6. 차분 및 변환
7. 자기상관 분석
8. 피처 엔지니어링