차트를 보다보면 이거 수많은 차트 이미지 딥러닝 모델에 학습시키면 사람이 일일이 공부할 필요도 없지 않을까?라는 생각이 들어 찾아봄

논문 정보
제목: Learning Predictive Candlestick Patterns: Vision Transformer Approach

저자/연도: Stanford Vision Lab, 2025

내용: 캔들차트 이미지를 Vision Transformer(ViT)에 학습시켜 단기 가격 예측 성공률 91% 달성.

특징: 인간 트레이더의 ‘시각적 직관’을 딥러닝 모델로 시각화함.

출처: CVPR Proceedings

• 논문 링크 바로가기
• 아래 글은 Moonlight & ChatGPT을 이용하여 공부한 내용을 작성.

0. 개요

• 연구 배경
  • 주식 시장에서 가격 변동 예측은 매우 중요
  • 이 가격 변동을 예측하는데 기술적 분석이 많이 활용됨. 그 중에서도 캔들차트가 대표적.
• 기존 접근 한계
  • 이 캔들차트로만 미래 가격을 신뢰성 있게 예측할 수 있는지에 대한 논란은 여전히 많다. (이 차트 패턴이 정말 예측 정보를 담고 있는 게 맞을까...?)
  • 기존 연구들은 통계쩍 지표나 시계열 모델을 이용한 수치 데이터 분석 위주. 패턴 자체를 학습한 연구는 거의 이루어지지 X.
• 연구 목적
  • Vision Transformer(ViT)모델 사용 -> 캔들차트 이미지로부터 주가 변동 패턴 학습 및 예측 검증[이미지 기반 예측]
• 연구 아이디어(2가지)
  • 가격 예측을 위한 분류
  • 자기 지도 학습

** 트랜스포머가 캔들차트 시각적 패턴 속에서 진짜 예측 신호를 학습할 수 있을까..?? **

1. Introduction 소개

삼성전자 캔들차트 출처

• 캔들차트(Candlestick chart)

  • 정의: 18세기 일본의 쌀 상인이 개발한 기법. 현재까지도 다양한 자산 가격 변동을 시각적으로 표현하는데 사용됨.
  • 구성
    • Open(시가)
    • High(고가)
    • Low(저가)
    • Close(종가)
  • 여론
    • 🙂: 시장 심리나 가격 추세 예측 가능!
    • 🙁: 흠...이 차트만으로 미래 가격을 예측하기에는 무리...
  • 기존의 연구(2. 에서 계속)
    • 기존의 연구들도 캔들 차트를 수집 방법, 정의, 양에 따라 서로 다른 결과를 내놓음.

• 연구 배경(기술) 및 연구 방법

  • ¹ViT 등장: 딥러닝 기반의 컴퓨터 비전 기술이 발전하면서 이미지 데이터를 다루는 Vision Transformer(ViT)가 등장.

• 연구방법

  • 1st. Multi-class classification을 통해 캔들 차트 이미지 입력 -> 미래 가격 움직임(상승 or 하락 or 유지) 직접 예측하도록 모델 학습
  • 2nd. 자기지도학습(Self-supervised learning) 기법인 Masked Autoencoders(MAE)를 결합해 이미지 일부 가리고(Masked) 나머지 정보를 복원하도록 학습 -> 라벨이 없어도 시각적 패턴을 스스로 학습한 뒤에 실제로 가격을 예측해보며 파인튜닝으로 성능 비교 (단, 두 ViT모델은 동일한 데이터셋과 동일한 학습조건-epoch 수로 훈련됨)

¹ViT: 이미지에도 텍스트 Transformer 구조를 적용. 전체이미지는 문장, 패치는 단어로 취급.
-> 이미지 전체 문맥(패치 간 관계)을 Transformer의 Self-Attention으로 학습. 

2. Literature Review 문헌 연구

• (앞에서도 언급했듯) 캔들차트 이미지를 활용한 컴퓨터 비전 기반 분석 연구는 매우 희소(sparse)한 상태!
• 기존 연구들은 수치형 OHLC 데이터 이용한 시계열 분석에 집중(캔들차트 시각적 정보는 시계열 데이터보다 구조적으로 불안정하기 때문)(있더라도 여러 모델 간의 성능 비교 or 패턴 감지하는 객체 탐지 연구 정도만) -> 이미지 자체로 가격 예측을 시도하는 이번 연구가 굉장히 이례적이고 독창적임

🤔이미지 처리 관련 분석 기술은 많았어도 왜 그동안 이미지 기반 캔들차트 분석 연구가 없었을까?

• 주식 종목과 차트 기준(틱, 분봉, 일봉, 주봉 등)마다 패턴이 크게 달라져서 모델이 특징을 잡기 어려워해 연구 결과도 다르고 예측 일관성을 유지하는 게 어려워서...?

3. Dataset 데이터셋

¹왜 '연속적'인 스냅샷이 필요할까?
-> 실제 트레이딩에서도 끊기지 않고 연속된 시간의 패턴을 보고 판단. 
이 논문에서도 끊기지 않는(intraday) 연속 구간 입력을 사용하면 모델 가격 움직임의 맥락을 놓치지 않을 수 있어서

²왜 25분후를 예측시점으로 설정했을까?
-> 논문에서 구체적인 근거는 제시 되지 않았지만 25분을 단기 예측의 최적점이라고 본 것 아닐까?
너무 짧으면 변동 폭이 작아 의미있는 패턴 잡기 어렵고 반대로 너무 길면 외부 요인의 영향이 커져 딱 캔들패턴만의 힘을 검증하기 어렵기 때문에 

4. Methods 방법

• 다중 클래스 이미지 분류로 접근
  • 입력: 캔들스틱 차트 이미지. ¹I ∈ R^(H×W ×3)
  • 출력: 미래 가격 움직임이 세 가지 클래스(Down/Flat/Up)중 어느 하나에 속할 확률 분포
  • 모델: ²Vistion Transformer (ViT) -> CNN보다 전역적 흐름을 더 잘 포착함.

 ¹I ∈ R^(H×W ×3)의 의미?
    -> 이미지는 실수(real numbers)로 구성된 3차원 텐서임. 높이 x 너비 x RGB 채널 수. 
    캔들 색상(초록/빨강)을 구분하기 위해 컬러 이미지 처리가 필요

 > ²ViT와 기존 CNN(합성곱 신경망) 성능 차이?
    -> CNN: 이미지 전체를 필터로 스캔. 합성곱 연산. 지역적 특징 추출. 계층적으로 전역 측징 구축
    vs ViT: 이미지 전체를 패치로 나누어 시퀀스 처리 + 모든 패치 쌍 간의 중요도 학습. Self-Attention. 전역적 특징 추출. 

4.1. Vision Transformer Architecture ViT 비전 트랜스포머 구조

기본 아키텍처: ¹ViT-Tiny

• 입력 이미지를 겹치지 않는 패치(patch) 단위로 ²분할
• 입력 크기: 224×224 픽셀 크기의 컬러 이미지(RGB=3채널)
• 패치 크기: 16×16 픽셀
• 패치 개수 N =(224/16)×(224/16)=196

=> 한 이미지는 196개의 패치로 나눠지게 된다.

¹ ViT-Tiny 기본 하이퍼파라미터 정보
-> 인코더 블록수(L): 12, 임베딩 차원(D): 192, MSA 헤드 수(H): 3
² 패치로 왜 잘라내는 걸까? 
-> 문장을 분석하려면 단어로 쪼개어 분석하는 것처럼 픽셀 대신 패치 단위로 잘게 쪼개어 Transformer 구조를 그대로 쓰기 위함! 

1단계: 이미지를 패치로 나누기

• 각 패치 $$ x_p \in \mathbb{R}^{P^2 \cdot 3} $$ 입력 이미지 크기: 224 x 224 픽셀. 패치 단위의 RGB 벡터로 변환
• Flatten 과정 거쳐 1차원 시퀀스로 정렬(하나의 패치 크기가 16x16x3 = 768, 즉 길이가 768인 1차원 벡터로 flatten 됨)

2단계: 패치를 벡터로 바꾸기

• 각 패치를 입력 정규화를 위해 ¹선형 투영을 통해 192차원 ²임베딩 벡터로 변환(아래는 선형 투영 식) $$ ³E \in \mathbb{R}^{(P^2 \cdot 3) \times d} $$

 ¹선형 투영(Linear Projection)을 꼭 해야할까?
 -> 트랜스포머 자체가 입력 차원이 일정해야 작동함. 지금 패치는 단순 일렬로 나열된 값의 개수나 너무 ㅁ낳고 
패치마다 정보량이 다르기 때문에 공통 차원인 d=192, 192차원으로 줄여서 다루기 쉽게 만드는 것!

 ²임베딩이란?
    -> 고차원 입력을 밀집된 벡터 공간으로 변환

 ³E: 학습 가능한 가중치 행렬. 패치를 새로운 표현공간으로 옮겨주는 역할

3단계: 시퀀스 구성

• 192차원의 임베딩 벡터로 변환 후(like 192개의 단어가 생긴 셈)
• 트랜스포머 기본
  • 순서가 있는 데이터를 학습 -> 패치들 순서 알려줘야[위치 임베딩]
  • 출력은 보통 문장의 대표 '요약 벡터' -> 클래스 토큰이라는 특별한 벡터를 앞에 붙여. 이 벡터가 모델이 이미지의 전체 의미를 요약하도록 학습(= CNN global pooling)

• 트랜스포머 최종 입력: $$ z_0 = [x_{\text{class}}; x_p^1 E; x_p^2 E; \ldots; x_p^N E] + E_{\text{pos}} $$

  • x_class: 이미지 전체 대표 요약 담당
  • x_p^iE : i번째 패치의 임베딩 벡터
  • E_pos: 각 패치의 위치 정보를

4단계: 트랜스포머 인코더 통과

사진 출처

인코더 블록은 12개의 블록(Layer)로 쌓여있고 각 블록의 구성은 다음과 같음

• MSA(Multi-Head Self-Attention) -> 패치 간 관계를 여러 관점에서 학습
• MLP(Multi-Layer Perceptron) -> 각 토큰 특징을 비선형적으로 확장
• LN(Layer Normalization) -> 학습 안정화
• 잔차 연결(Residual Connection) 적용 -> 기존 정보 보존 및 그라디언트 소실 방지

=> 위 과정을 거치면 맨 앞의 클래스 토큰( x_class)이 전체 이미지 특징을 요약한 벡터로 변함. 이 벡터가 분류기에 입력되어 최종적으로 이미지 레이블 예측 가능!

ViT 프로세스 요약 : 이미지를 패치 단위로 분할 -> 각 패치를 토큰처럼 임베딩 & Trasnformer 인코더로 처리 -> 이미지 내 지역적/전역적 관계를 동시에 학습

4.2. Training Strategies 훈련 전략

전이학습 활용

• 사전 학습된 가중치 사용: ImageNet-1k 데이터셋으로 미리 학습된 ViT가중치를 초기값으로 사용.
  • (참고) ImageNet-1k은 자연 이미지 기반이지만 기본적인 시각적 패턴(윤곽선, 형태 , 질감 등)을 이미 학습했기 떄문에 차트 데이터에도 적용 가능

첫 번째 접근방식: ViT + 분류층 추가

• 입력: 캔들 차트 RGB 이미지
• 구조: ViT 클래스 토큰을 선형 분류층(Linear Classifier)에 연결해 세 가지 클래스 확률 계산(아래는 계산식)
• 출력: 미래 가격 움직임이 3개 클래스(Up/Flat/Down) 중 하나일 확률
• 학습: 손실함수 통해 예측값과 실제 라벨값 차이를 줄여 => 의미있는 시각적 표현 학습할 수 있또록

4.3. Self-Supervised Pretraining with Masked Autoencoders MAE를 이용한 자기 지도 학습

두 번째 접근: MAE(MAsked Autoencoder) 기반 자기지도 학습

• 라벨 없이 학습(¹Self-supervised): 차트 이미지 일부(75%)를 ²랜덤으로 가리고 나머지 ³25%만 보고 원래 이미지 복원하도록)
• 구조
  • Encoder 𝑓_𝜃: 보이는 패치들만 ViT 구조로 처리
  • ⁴Decoder 𝑔_𝜙: 인코딩된 표현 바탕 -> 마스크된 패치들에 대해 서만 재구성 손실을 ⁵계산하여 전체 이미지 복원(⁶가벼운 구조 사용)(아래는 재구성 손실 계산식)

=> 캔들스틱 로컬(캔들 간 관계) + 글로벌(전체 추세) 패턴 동시 학습 가능 & 더 깊은 시각적 이해

¹ 직접적인 분류 목표 x: 이건 Up이야, Down이야 맞히는 게 목표 x -> 가려진 이미지 복원해서 내부 패턴 잘 이해해라. 정답 레벨 없음 = Self-supervised learning

² 랜덤으로 가린다
-> 패치 인덱스를 무작위로 섞어 상위 N(1-m)개의 패치만 남긴다. 특정 위치에 의존하지 않으면서 일부만 사용하겠다는 뜻. (N=100. m=0.75면 25개의 패치만 남긴다는 뜻)
³ 여기서는 남은 25% 패치만 인코더에 입력 -> 이 일부만 보고 전체 그림 유추
⁴ 디코더 입력 형태
-> 인코더 출력 + 마스크 토큰 함께 입력받음. 단순 복원용이어서 경량 구조 사용
⁵ 손실 함수 계산 = 숨겨진 부분(마스크) 얼마나 잘 맞췄는지만 확인 
⁶ 표현을 학습하는 것이 중요한 MAE의 인코더와 달리 디코더는 단순 복원용이기에 굳이 복잡할 필요 x. 학습 효율 향상과 계산 비용 절감 위함. 

4.4. 구현 세부사항 Implementation Details

• 안정적인 학습 설정
  • 과적합 방지 -> ²AdamW ¹옵티마이저 + ³weight decay λ = 0.05) 사용
• 최소한의 데이터 증강
  • ⁴수평 이동만 적용
• 정규화
  • 사전 학습 모델(ImageNet)과 입력 데이터 분포 맞추기 위해
  • 입력 이미지 픽셀값을 평균 & 표준편차로 ⁵정규화

¹ 옵티마이저: 모델 학습할 때, 손실을 최소화하도록 가중치를 조정하는 알고리즘. 얼마나, 어떤 방향으로 조정할지 결정.
² AdamW은 기존 Adam보다 정규화 효과가 더 강함(AdamW는 가중치 감쇠를 별도로 적용 -> 과적합 방지에 더 효과적)
³ 가중치 감쇠
-> 가중치 값이 과도하게 커지는 것을 막아 입력 변화에 덜 민감하고 일반화된 학습 유도
⁴ 수평 이동을 하면 동일한 패턴을 다양한 시점에서 학습하게함.(e.g, Day1~Day5, Day2~Day6..) => 모델이 특정 날짜 위치에 과도하게 의존하지 않도록 과적합 완화.
⁵ 정규화: <모델 학습 전 입력 데이터 전처리 단계>에서 입력 데이터(입력 이미지 픽셀 값) 분포를 모델 학습 분포와 일정하게 맞추는 과정. (xᵢⱼ - mean) / std

4.5. Interpretability Analysis 해석 분석

MAE 학습한 잠재표현 안 패턴들 분석

• 클러스터링 분석
  • 1st. 트랜스포터 인코더 통과 뒤 클래스 토큰에서 피처 벡터 추출
  • 2nd. K-means clustering 적용(k=20)해 비슷한 패턴 샘플들 그룹화
  • 3rd. 각 군집 안 실제 정답 분포 확인 -> 모델의 일관성 평가 '비슷한 차트 이미지 모델이 같은 방향으로 잘 예측하고 있는가?'
    • 클러스터 순도 P_c 계산-> 각 군집에서 가장 많이 등장한 클래스 비율
    • e.g., 어떤 군집 대부분 샘플을 상승으로 예측 -> p_c 값 매우 높게. 일관된 패턴 포착 잘하고 있음.

5. Experiments 실험

5.1. Baselines 기준 모델

• MAE 기반 접근법 성능 확인 위해 두 가지 금융 예측 모델 사용
• 1) ¹RSI Statisticlcal Strategy(전통적 통계적 RSI 전략)
  • ²개념: 일정 기간 동안 가격 상승폭과 하락폭 비교 -> 주가의 과매수/과매도 상태 판단. 주가 추세 전환 가능성 탐지하는데 사용
  • 예시: RSI 값 낮아(높아) 과매도(과매수) 상태-> Up(Down) 예측(중간 값 근처라면 Flat으로 분류)
• 2) ³RNN with ⁴LSTM(시계열 기반 순환신경망)
  • 구성: 3개의 은닉층(128, 64, 32 유닛) 사용 & ⁵dropout rate: 0.2 & 활성화 함수: tanh

¹ RSI: Relative Strength Index, 상대적 강도 지수, 심리와 과열 정도 지표. 최근 며칠동안 주가를 비교해서 지금 주가가 너무 올랐는지(과매수) 아니면 너무 떨어졌는지(과매도) 판단하는 지표. 오른 날이 많으면 RSI값은 높아지고, 반대로 주가가 내린 날이 많으면 RSI값은 낮아짐.
² (구체적) RSI 값이 낮다(높다) -> 최근에 주가가 너무 많이 낮아진(높아진) 상태 = 과매도(과매수) 상태 => 곧 반등(하락)할 수 있다는 신호로 해석
³ RNN: Recurrent Neural Network. 계열 데이터 다루는 대표적인 딥러닝 모델. e.g, 주가, 온도, 음악, 문장 등 -> 이전 단계 정보를 다음 단계로 전달하며 기억을 유지하며 '앞에서 본 걸 기억하고 다음을 예측하는 모델'
⁴ LSTM이 무엇인가요?: Long Short-Term Memory. 기억 셀(cell) 구조를 추가해 RNN이 오래된 정보는 잊어버린다는 단점을 개선한 업그레이드 버전.
⁵ dropout: 과적합 막는 방법. 일부 뉴런을 무작위로 꺼서(=0으로 만들어서) 모델이 한 가지 패턴에 너무 의존하지 않게 만드는 장치.

5.2. Results 결과

• Vit-MAE Clustered 모델의 독보적 성능
  • 전통적인 시계열 분석 / 단순 ViT 모델 대비 가장 높은 예측 정확도
  • 보합(Flat) 상태 비율은 실제 데이터 분포와 가장 유사하게 예측(0.86)

6. Conclusion 결론

기존 RNN 모델이나 기술적 지표보다 Vision Transformer가 캔들스틱 차트로부터 주가 단기 변동을 높은 정확도로 예측할 수 있음을 보여준다.

** Key Points**

• 기술적 분석의 데이터 타당성
  • 캔들스틱 차트 패턴 안에는 실제로 주가 변동을 예측하는 데도움이 되는 '신호'가 존재함이 증명됨. -> 기술적 분석이 단순한 감이 아니라 통계적 타당성을 가질 수 있음을 시사
• 자기 지도학습(MAE) 효과
  • MAE 복원 과정에서 시각정 특징 더 깊게 이해 & 유사한 패턴끼리 잘 묶이는 클러스터링 가능 -> 기존 다중 분류 모델보다 예측력 크게 향상

6.1. Limitations 한계

• 특정 시장/주식 한정:
  • 정상적인 시장 상황 & 유동성 높은 주식(Liquid stock)에만 한정 -> 비정상적인 시장상황(e.g, 금융 위기 등)이거나 유동성 높은 주식에서는 모델 성능 저하 가능
• 정보 제한
  • 오직 캔들스틱의 시각적 정보(OHLC 데이터)만 사용
  • ¹거래량(volume)이나 ²기본적 데이터(fundamental data)를 통합 X -> 주식 움직임 예측은 가능하지만 이유는 설명 못 함.
• 단기 예측(intraday) 한계
  • 30개의 캔들(총 2.5시간)로 구성된 스냅샷 분석 + 25분 후의 가격 변동 예측에 초점 -> 장기간 패턴 탐구에는 한계 o
• 제일 중요한 것
  • 편향된 방향성 예측 -> 상승/하락보다 보합(Flat) 예측을 가장 잘함. 실제 트레이딩에서는 상승/하락 방향 예측 필수 -> 실제 트레이딩 시스템에 적용하기에는 가장 중요한 한계로 작용

¹거래량: 시장의 관심도나 강도 나타내는 지표
²기본적 데이터: 기업 재무상태, 산업 동향 등

6.2. Future Work 후속 연구

• 멀티모달 모델로 확장 -> 감정(sentiment) 데이터 결합해 시장 심리까지 반영할 예정
• 다양한 자산군에 대한 실험(e.g, 외환, 암호화폐, 원자재 등)을 통해 다양한 시장에서의 모델 검증
• 실시간 거래 시스템 개발 -> 리스크 관리 로직 통합되도록
• 장기 패턴 탐구 -> 일봉/주봉 차트 등 장기간 패턴도 탐구해 단기 예측 중심 모델의 한계 보완해볼 것

😊느낀점: 기존 자연어 처리 분야에서 사용되던 ViT 딥러닝 모델을 이용해 캔들스틱 차트 이미지에서 단기적으로 주가 변동을 예측하는 유효한 신호가 포착될 수 있음을 실험으로 증명한 글이다. 나도 그동안 '직관' '감'으로만 여기던 기술적 분석이 어느정도 데이터적으로 타당성을 가질 수 있음을 깨달았고 많은 모델 중에서도 MAE와 같은 자기 지도 학습 전략이 노이즈를 극복하고 최적의 학습 효과를 내는데 중요한 열쇠임을 알 수 있었다. 아직까지는(내가 아는 선에서) AI가 주가를 완벽하게 예측할 수 없다고 알고있지만 위 향후 현구에서 언급되었듯 다양한 정보를 통합하고 장기 예측 패턴도 계속해서 연구한다면 ViT가 금융 시장 분석에 있어 중요하게 자리매김하지 않을까 생각한다.

이 글은 Do it! BERT와 GPT로 배우는 자연어 처리: 트랜스포머 핵심 원리와 허깅페이스 패키지 활용법 <2장 문장을 작은 단위로 쪼개기>를 읽고 공부하며 작성한 내용입니다.

기계를 공부하는 사람이 기계를 가장 잘 이해하기 위해 기계를 부품으로 분해하듯,

자연어 처리를 본격적으로 시작하기 전에 컴퓨터가 문장 또는 문서를 잘 이해할 수 있도록 작은 단위로 나누는 과정이 필요하다, 이를 NLP에서는 토큰화(tokenization) 라고 부른다.

Tokenization 토큰화

• 정의: 문장을 토큰(token) 시퀀스로 나누는 과정. 최신 NLP 모델(e.g,트랜스포머 모델)의 기본 입력 형태도 이 '토큰 시퀀스'임

• 방법: 토크나이저(tokenizer)라는 프로그램이 토큰화 수행 e.g, 한국어 형태소 분석기인 은전한닢(Mecab), 꼬꼬마(Kkma) 등

• 종류

  • 단어(어절) 단위 토큰화(Word-level)

    • 장점: 공백 기준 분리 가능해 구현 간단
      • 단점: 어휘 집합(vocabulary) 크기가 매우 커져 학습 효율 저하 발생 가능 e.g, 갔었어, 갔었지, 갔었어요, 갔었는데요 등 -> 사실상 같은 의미지만 모두 다른 토큰으로 처리됨. 이를 해결하기 위해 '갔었' 같은 의미있는 단위로 나누는 형태소 분석을 사용하기도

  • 문자 단위 토큰화(Character-level)

    • 장점: 한글 표현 가능 글자 수 (11,172개) + 영어, 숫자 포함해도 어휘 집합 크기 엄청 크지 않음. 신조어나 미등록 토큰(Out-of-Vocabulary, OOV) 문제에서도 자유로움
      • 단점: 각 문자가 독립적인 의미 가지기 어려움 -> 문맥 파악 힘듦 & 토큰 시퀀스 길어져 모델 성능 떨어질 수도

  • 서브워드subword 단위 토큰화(Subword-level)

    • 장점: 단어 단위와 문자 단위 장점 절충. 대표적인 기법이 바로 바이트 페어 인코딩(Byte Pair Encoding, BPE), WordPiece, SentencePiece
    • 효과: 의미 단어 잘 포착 가능, OOV 문제 완화, 어휘 집합 크기 문제 줄이기 가능

• unhappiness 토큰화 예시(위 토큰화 종류)

  • 단어(어절) 단위 토큰화: "unhappiness" 단어 전체를 하나의 토큰으로 취급
  • 문자 단위 토큰화: "u", "n", "h", "a", "p", "p", "i", "n", "e", "s", "s"
  • 서브워드 단위 토큰화: "un", "happi", "ness"

BPE(Byte Pair Encoding, 바이트 페어 인코딩)

역사 및 정의

• 1994년 제안된 데이터 압축 알고리즘에서 시작.
• 가장 자주 등장하는 문자열 쌍을 점진적으로 병합 & 새로운 기호(토큰)로 치환 -> 사전 크기와 시퀀스 길이 균형 맞춤
• NLP에서는 이 원리를 변형 -> 자주 등장하는 글자/부분 문자열 합쳐 서브워드 단위 어휘집합 구축할 때 활용

예시

e.g, abccbaaabcbcbaaa

• 가장 자주 등장한(4번)aa를 Z로 병합: abccbZabcbcbZa
• 가장 자주 등장한(3번) bc와 cb중에 알파벳 순으로 bc를 Y로 병합: aYcbZaYYbZa
• 가장 자주 등장한(2번) aY, bZ, Za중에 마찬가지로 알파벳 순으로 aY를 X로 병합: XcbZXYbZa
• 가장 자주 등장한(2번) bZ를 W로 병합: XcWXYWa

=> 결과적으로 어휘 집합 크기가 3개(a, b, c)에서 7개(a, b, c, W, X, Y, Z)로 늘어났지만 데이터 길이(시퀀스 실이)는 16에서 7로 줄었다.효율적

BPE 어휘 집합 구축

• 정의: 자주 등장하는 문자열 쌍 병합 -> 새로운 서브워드 만들고 어휘집합에 추가(원하는 어휘 집합 크기가 될 때까지 반복)

• 구축 과정:

  • step1.텍스트를 프리토크나이즈(pre-tokenize) (보통 공백 기준)
  • step2.모든 단어를 글자 단위로 분리
  • step3.자주 등장하는 바이그램(bigram, 연속된 두 글자) 쌍을 찾음
  • step4.그 쌍을 병합(merge)하여 새로운 토큰으로 추가
  • step5. 원하는 어휘집합 크기가 될 때까지 반복(집합 크기vocab size는 사람이 직접 정할 수 있음)

BPE 토큰화

• 정의: 위에서 구축된 BPE 어휘집합을 기준으로, 새로운 문장을 가장 긴 서브워드 단위로 분해하는 과정.

• 절차

  • step1. 공백 단위로 프리토크나이즈
  • step2. 단어를 글자 단위로 쪼갠 후, BPE 병합 우선순위 적용
  • step3. 병합된 토큰이 어휘집합에 있는지 확인
  • step4. 더 이상 병합할 게 없으면 종료 (참고: 어휘집합에 없는 경우 <unk>로 처리)

(참고) 워드피스(WordPiece)와 비교

• 공통점: 자주 등장하는 문자열을 '토큰'으로 인식

• 차이점:

  • 어휘 구축 기준

    • BPE: 단순 빈도 기반(가장 자주 등장한 쌍 병합)
    • WordPiece: 말뭉치의 우도(likelihood) 최대화 -> 등장 확률 기반

  • (허깅페이스 tokenizers) 토큰화 수행 방식

    • BPE: 병합 우선순위대로 반복해서 병합 후 최종 확인
    • WordPiece: 주어진 어휘 집합만 보고 가장 긴 매칭 서브워드 찾아 분리.

  방식	토큰화 결과	특징
  BPE	["un", "happy", "ness"]	- 가장 자주 등장하는 문자열 쌍을 병합 - 규칙 단순, 빠르고 효율적
  WordPiece	["un", "happi", "ness"]	- 문장 확률(likelihood)을 높이는 병합 선택 - 확률 계산을 통해 더 적절한 분리 가능

BPE GPT & BERT코드 (코랩 실습)

• 코드 실습은 크게 세단계로 나뉜다. 1. 어휘집합 구축 -> 2. 토큰화 -> 3. 토크나이저

1. 어휘집합 구축

• 목적: NSMC데이터로 GPT/BERT용 어휘집합 만들기

• 과정:

  • Korpora 라이브러리 데이터 다운로드
  • BBPE 어휘집합 구축 -> vocab.json, merges.txt 생성
  • Wordpiece 어휘집합 구축 -> vocab.txt 생성
  • 구글 드라이브에 저장

2. 토큰화

• 목적: 저장된 어휘집합 -> 문장 모델 입력값 변환

3. 토크나이저 프로세스

• 공통: 토크나이저 선언 -> 문장 토큰화 -> batch 입력 생성(padding, truncation, max_length 등)

• 3.1. GPT 토크나이저

  • 방식: BBPE(바이트 레벨)
  • 출력: input_ids, attention_mask

• 3.2. BERT 토크나이저

  • 방식: WordPiece
  • 출력: input_ids, attention_mask, token_type_ids

이 글은 Do it! BERT와 GPT로 배우는 자연어 처리: 트랜스포머 핵심 원리와 허깅페이스 패키지 활용법 <1장 처음 만나는 자연어 처리>를 읽고 공부하며 작성한 내용입니다.

Natural Language Processing

• 정의: 사람이 사용하는 언어(자연어)를 컴퓨터가 이해하고 처리하도록 만드는 기술
• 활용: 번역기, 유튜브 자막, 챗봇, 검색 엔진 등

여기서 중요한 질문 “컴퓨터가 언어를 이해한다는 것은 무엇을 의미할까?”

Computers understand human languages.

• 컴퓨터가 인간처럼 언어의 의미를 이해한다.(X)
• 컴퓨터는 입력된 문장을 계산을 통해 확률로 처리한다.(O)

예를 들어 “나는 행복하다”라는 문장을 입력 -> 모델은 이 문장이 긍정일 확률 0.9, 중립일 확률 0.1과 같은 식으로 출력. 즉, 이해라기보다는 확률 계산에 가까움.

NLP Model

• 정의: 특정 입력값(문장이나 문서 형태의 자연어)을 받아 해당 입력이 특정 범주에 속할 확률을 반환하는 함수.
• 예시: 감성 분석 모델 -> 하나의 문장을 입력받아 긍정, 부정, 중립 범주에 속할 확률을 출력

Basic terms in NLP Models

자연어 처리 모델이 동작하기 위해서는 학습 과정이 필요

• 레이블(Label): 학습 데이터의 정답. 예) “나는 행복하다” -> "긍정" 라벨링(labeling)
• 학습(Learn): 모델이 데이터 패턴을 익히는 과정.
• 업데이트(Update): 모델이 예측한 값과 정답의 차이를 줄여가는 과정.
• 트레인(Train): 학습과 업데이트를 반복하는 전체 과정.
• 후처리(Post-processing): 모델이 출력한 확률값을 사람이 이해할 수 있는 언어(자연어)로 바꿔주는 단계.

Deep Learning in NLP

딥러닝: 인간의 뇌 구조를 본뜬 인공 신경망을 깊고 촘촘하게 쌓아 올려 -> 모델이 데이터 패턴을 스스로 학습하도록 하는 방법

자연어 처리 분야에서는 특히 트랜스포머(Transformer) 기반 모델이 많이 쓰임. 트랜스포머 모델 예시

• BERT: 양방향 문맥을 이해. 빈칸 채우기 같은 태스크에 강함
• GPT: 순방향 문맥을 이해. 다음 단어 예측하기 같은 태스크에 강함. 문장 생성에 활용됨.

Transfer Learning in NLP

자연어 처리 모델은 보통 트랜스퍼 러닝 방식 사용.

• 트랜스퍼 러닝이란? 한 번 학습한 지식을 다른 과제에 재활용하는 기법

Upstream Task (사전 학습)

• 대규모 말뭉치로 문맥을 이해하게 만드는 기본 훈련 단계

  • BERT 계열: 빈칸 채우기(마스크 언어 모델)
  • GPT 계열: 다음 단어 맞히기

Downstream Task (실제 활용)

• 실생활 속 구체적인 과제들...

  • 문서 분류: 리뷰가 긍정/부정인지 판별
  • 자연어 추론: 두 문장이 모순인지, 참인지, 중립인지 판별
  • 개체명 인식: 문장에서 “서울”은 장소, “이순신”은 인물처럼 범주 구분
  • 질의응답: 질문과 지문을 입력받아 정답 추출
  • 문장 생성: 번역, 요약, 대화 생성 등

• 다운스트림 태스크 수행 전략

  • 파인튜닝(Fine-tuning): 모델 전체를 새로운 데이터에 맞게 다시 학습

  • 프롬프트 튜닝(Prompt tuning): 모델 일부만 업데이트

  • 인컨텍스트 러닝(In-context learning): 모델을 업데이트하지 않고 예시만 제공

    • 제로샷: 예시 없이 수행

    • 원샷: 예시 1개만 제공

    • 퓨샷: 예시 몇 개 제공

(7Steps) How NLP Models Learn

자연어 처리 모델을 실제로 학습할 때는 다음과 같은 흐름을 따름

1. 설정값 정의: 하이퍼파라미터, 러닝레이트, 배치 크기 등
2. 데이터 준비: 학습/평가용 데이터셋 다운로드
3. 사전 학습 모델 불러오기: 허깅페이스 트랜스포머 등
4. 토크나이저 준비: 문장을 토큰 단위로 변환
5. 데이터 로더 준비: 데이터를 배치 단위로 모델에 전달
6. 태스크 정의: 분류, 질의응답 등 목적에 맞는 태스크 지정
7. 모델 학습: 설정한 조건으로 트레이너를 통해 학습 수행

위 과정을 요리에 비유하면 아래와 같다..

1. 설정값 정의 = 요리 레시피 정하기
2. 데이터 준비 = 재료 사오기
3. 사전 학습 모델 불러오기 = 반조리 식품 꺼내오기
4. 토크나이저 준비 = 재료 손질하기
5. 데이터 로더 준비 = 재료를 일정량씩 덜어내어 (배치 단위)한 접시씩 올려놓기
6. 태스크 정의 = 요리 방식 결정하기
7. 모델 학습 = 실제 요리하기

Conclusion

번역기, 챗봇, 추천 시스템, 그리고 계속해서 주목받고 있는 생성형 AI까지 모두 자연어 처리 모델 위에서 돌아가고 있다.

처음 공부할 때는 큰 그림(업스트림 → 다운스트림)을 먼저 이해하고, 그 안에서 세부 개념(BERT, GPT, 파인튜닝 등)을 차근차근 익히는 것이 중요해보인다.

기초는 이정도로 공부하고 앞으로 조금 더 심화 개념을 공부해보도록 한다..!!

이 글은 주식 투자를 처음 시작하며 공부한 내용을 정리한 것입니다. 내용에 오류가 있을 수 있으며, 특정 종목에 대한 투자 권유가 아닙니다. 모든 투자 판단과 결과에 대한 책임은 오직 본인에게 있으니, 충분한 학습과 분석을 통해 신중하게 투자하시기를 바랍니다.

(아래 내용은 책 <주식 단타로 매일매일 벌어봤어?> 3장 '단타 고수들의 트레이딩 테크닉' 중 1) 상한가 따라잡기(상따) - 상한가 유형분석 (p.128~p.138)을 참고하여 작성되었습니다.)

상한가 따라잡기란?

한 종목 주가가 상승할 때, 당일 최고가를 의미. 이 상한가를 따라잡아 매수하는 것을 의미.

상한가 따라잡기를 하는 이유는?

다음 날 장 시작할 때 시초가 갭상승과 추가적인 주가 상승을 노리는 것 . . . 상한가 따라잡기 유형에는 크게 4가지가 있다.

1) 장대 양봉 2) T자 3) 아래꼬리형 4) 점한상가

*상한가에 진입했을 때 같이 매수하는 것이 일반적이나 최근에는 조금 더 일찍 매수하기도!
**상한가가 풀리는 경우가 자주 발생하며, 풀린 후에는 주가가 급락할 수 있다...
-> 그래서 시간 외 거래 흐름까지 파악해야하는데 그럴 시간적 여유가 없는 직장인에게는 권장되지 않는 매매법이라고 한다..!

1. 장대양봉형

의미

시가 대비 종가가 크게 상승하여 몸통이 상하로 길~~게 나타나는 양봉 캔들을 의미

차트 분석

-> 2025/09/15(월) 농심 홀딩스는 12일 금요일 종가보다 낮은 시가로 출발했지만 장중 강한 매수세가 유입되어 당일 종하는 상한가(30.0%)로 마감되며 '종가 상한가'를 기록함.

2. 십자형(도지형)

의미

시가 & 종가 거의 같은 패턴 -> 캔들 몸통이 거의 없는 십자(十) 모양의 패턴

차트 분석

탑코미디어는 2025/09/15(월) 일봉 차트에서 十자의 모습을 나타내므로 장중 큰 병동을 겪지만 시가와 종가가 거의 같은 가격으로 마감된 것을 볼 수 있다. 이렇게 장중 변동성이 큰 종목은 다음 날에도 변동성이 클 수 있다.(하락 추세 끝 or 상승 추세 중 -> 상승 가능성 ㅇ / 상승 추세 끝 -> 하락 가능성 ㅇ)

십자형 말고도 T자형이 있다.

• 의미: 시가 & 종가 & 고가 모두 거의 같은 패턴(하락 추세 끝 -> 망치형 캔들, 상승 가능성 ㅇ / 상승 추세 끝 -> 교수형 캔들, 하락 가능성 ㅇ)

3. 아래꼬리형

의미

주가가 장 초반에 하락하나 강력한 매수세가 유입되어 상승 반전에 성공하는 패턴.

차트 분석

흠... 사실 이 내용이 내가 책 내용을 잘못 이해하고 있는 건지 AI 검토 내용이랑 좀 다르게 나온다.

나는 n개월을 기준(지금 보면 8, 9월)으로 전체 추세가 긴 꼬리라고 생각했는데 AI(Gemini 2.5 Flash)는 당일 장중 분봉 데이터를 통해 확인하는 것이 가장 정확하다고 한다...일봉 차트로는 큰 그림을 확인하는 정도! 그러면 저 오른쪽 차크에서 09/17 09:00~09:30 까지봐도 아래꼬리형 패턴이 나타난다고 할 수 있겠다...!

어쨌든 큰 그림 먼저 살펴보면 빌리언스는 시가가 높게 시작했으나 주가가 하락하면서 점점 상승 추세를 보이고 있다.이렇게 시가가 높을 때는 추격 매수보다는 하락을 기다려 눌림을 공략하는 게 더 효과적이라고 한다. 오른쪽 차트를 보면 2025/09/16에도 상한가를 진입했지만 계속해서 지렁이 패턴이 만들어지면서 상한가가 계속 풀리는 모습이 보였다. 다음날 시가에서도 이 지렁이 패턴 계속 나타나지만 이후에는 고가가 크게 상승하고 있는 모습을 보이고 있다..!

• 눌림목 매매란? 상승추세중인 주가에서 '일시적'으로 하락하는 구간노려 저점매수하는 전략. (상승중-일시적 하락-저점매수. 이때 잠시 하락하는 그 지점을 '눌림목'이라고 함. 상대적으로 낮은 가격에 진입 가능)(근데 일시적이 아닌 추세 하락의 시작일 수도...껄껄

• 이때 확인해야 할 것이 거래량이 급감하는지? 중요한 지지선을 이탈하는지? 이런 경우를 위해 손절가 정해두어야)

4. 점상한가형

의미

시가 & 종가 & 고가 & 저가 모두 상한가로 형성. 즉, 아침 9시(시가)부터 장 마감시간(종가)까지 한 번도 상한가를 이탈하지않고 종일 상한가를 유지하는 패턴(——— 이렇게 곧은 가로선 모양)

차트 분석

일봉 차트에서 캔들 위, 아래 꼬리가 전혀없다...! 완벽한 점상한가형. 이러한 종목은 다음 날에도 상승하는 가능성이 높아 최대한 보유하는 것이 좋다고 하는데....그런데....

(후후...역시나 매수 추세가 강해서 그런지 주문을 넣어도 체결이 쉽지 않은 상황 -> 약간 높은 가격으로 매수 정정을 해도 매수 체결이 안되어 결국 취소함...! = 진입하기 매우 어려운 패턴)

캔들 분석의 위험과 의의

What people usually say...'캔들 분석, 추세, 차트만 보고 주식하는 것을 사람들이 위험해ㅐㅐ!!! 라고 하는 것을 들어본 적이 있다...

그 이유를 당장 위 차트에서도 알 수 있다. 와이랩 종목 차트 곳곳에 T자형 캔들이 나타나지만, 어떤 경우에는 상승하고 어떤 경우에는 하락하는 등 전혀 다른 추세를 보인다. 즉 똑같은 모양의 캔들이라도 나타나는 위치나 시장 상황에 따라 의미가 충.분.히 달라질 수 있다는 뜻이다.

따라서 캔들 분석은 매매를 결정하는 수많은 근거 중 하나로 생각해야지 이것만을 유일한 근거로 삼고 매매하면... 큰 손실을 초래할 수 있다....⊙﹏⊙∥

물론, 캔들 분석은 주식 투자를 처음 시작하는 (나같은) 주린이들에게는 정말 재밌고 쉽게 다가갈 수 있는 지표임은 분명하다 (오오! 빨강!! 오오 T자!!!!)

그러니 이 캔들 (일봉) 차트를 볼 때는 분봉 차트, 시장 시황, 기업 이슈등 다양한 매매 근거를 함께 분석하여 최적의 선택을 하는 것이 중요하다!!

(난 앞으로 캔들 공부를 조금 더 해볼 것이다 껄껄 φ(゜▽゜*)♪)

참고: 양선호, 『주식 단타로 매일매일 벌어봤어? - 주린이를 위한 실전 단타 입문서』, 넥서스, 2022. 주식 차트 보는 법 및 용어정리 1 주식 차트 보는 법 및 용어정리 2

투자에서 제일 중요한 것은 시드머니(자본금)과 테크닉(전략)이라고 생각한다. 그 중에서도 '이해'하고 투자하는 것이 중요하니 이 테크닉(전략)의 중요성은 더 말하지 않아도 되겠다.

이 투자 전략을 세우고 나서 자동 매매 프로그램을 만들때 주요 프로세스는 아래와 같다.

    전략 선택 -> 전략 이해 및 코드 구현 -> 백테스트

여기서 백테스트는 실전에 투입되기 전 과거 데이터로 내가 구현한 전략이 얼마나 정확한지 테스트하는 것이다. (마치 머신러닝에서 쓰이는 val_data처럼)

아래 글도 마찬가지로

• 어떤 전략을 선택했는지
• 그 전략에 대한 이해와 코드로 어떻게 구현할 수 있는지
• 마지막으로 백테스트를 구현하는 것까지 자세하게 적어보았다.

그럼 가 보 자 고 !

두다다다다다다다
두다다다다다다다
　(∩`・ω・)  ~ ♪
＿/_ミつ/￣￣￣/
　　＼/＿＿＿/

주식의 주요 투자 전략에는 아래와 같이 정말 다양하게 있다.

-> 이 중에서 초보자도 알기 쉽고 가장 많은 신뢰를 받는 지표이자 전략은 바로 이동 평균선

이동 평균선은 여러 가지 기술적 지표 중에서 가장 많은 사람들이 사용하는 것 중의 하나다. — 양선호, 『주식 단타로 매일매일 벌어봤어?』, 넥서스, 2022, p.62

이동 평균선의 장점

• 단순함: 계산이 다른 전략에 비해 간단하고 직관적
• 시각화 용이: 글이아닌 차트로 보기 쉬움
• 구현 난이도: 코딩하기 쉬운 편에 속함

나같은 초보가 첫 번째 투자전략으로 선택할 때는 이동평균선이 더할나위 없이 좋은 선택...!

1.이동 평균선

1.1. 정의

: Simple Moving Average(줄여서 SMA).이전 데이터로 평균을 내 추세를 통해 신호를 판단하는 후행성 지표. SMAn은 이전 n개의 값을 평균 낸 값을 그래프로 그린 것을 의미.(n이 클수록 전반적인 흐름을 알 수 있고, 작을수록 주가 그래프에 가까워진다.)

기본 코드

자 그러면 단기 변동성과 단기 추세 파악에 주로 사용되는 SMA5을 코드로 어떻게 나타낼 수 있을까?

일단 이전 글 파일 구조에 이어서 strategies 라는 이름의 디렉토리를 새로 만들어 그 안에 moving_avg.py 파이썬 파일을 만들어주었다.

    AutomatedTrading/
├── access_token.txt 
├── auth.py                    # 토큰 발급 (공통)
├── market_data.py            # 데이터 수집 (공통)
├── strategies/
   ├── moving_average.py     # 이동평균선 전략

*참고: 기간에 따른 대표적인 추세 전환 지표로는SMA20(중세) 그리고 SMA60과 SMA120(장기)이 활용된다.

1.2. 개념 이해

: 쉽게 이야기하면 상승 또는 하락 추세에서 현재 단기 이동평균선이 중장기 이동평균선과 비교해 어떠한 흐름을 띠고 어떻게 치고 내리는지 그 흐름에 따라 주식을 매수할 것인지 매도할 것인지 결정하는 것이다.

보다 자세하게 이동평균선을 이해하고 싶으면 아래 링크에서 확인할 수 있다. - 상승 추세에서의 투자 전략(iM증권) - 하락 추세에서의 투자 전략(iM증권)

중요 용어

: 전반적인 추세와 단기 이동평균선이 중장기 이동평균선을 어떻게 치고 올라가는지(내려가는지)도 중요한데 특히 추세 신호의 전환을 파악하는데 폭넓게 사용되고 있는 개념이 바로 골든 크로스 & 데드 크로스 이다.

• ⬆️ 골든 크로스: 강세 전환. 단기 이동 평균선이 장기 이동 평균선을 아래에서 위로 급속하게 뚫고 올라가는 상황. 실전일 때는 욕심부리다가 꼭대기 놓칠 수 있으니 슬슬 매도 준비해야 함.

• ⬇️ 데드 크로스: 약세 전환. 단기 이동 평균선이 장기 이동 평균선을 위에서 아래로 급속하게 뚫고 올라가는 상황.

  Q. 골든 크로스는 상승 추세를 의미하니 매수를 해야하고 데드 크로스는 하락 추세를 의미하니 매도를 해야하는 게 맞나요? A. 그것이 기본원리지만 이동평균선은 후행성 지표인 만큼 이미 신호가 늦은 것일 수도 있다. 따라서 한 박자 빠르게 생각하고 활용하는 것 또한 필요하다. 자세한 내용은 아래 표를 참고하자.

  

  => 결론적으로 둘 다 맞는 전략이다. 트레이더의 성향과 목적에 따라 선택하곤 한다. 단 이번 글은 자동 매매 프로그램의 기초를 다지는 단계이기 때문에 상승 추세일 때는 매수 & 하락 추세 일때는 매도 이 기본 로직으로 프로그램을 만들어본다.

1.3. 코드 구현

: 정말 이 매매 전략이 천차만별이다. 나는 전략의 기준도 잘 모르기에 코드잇 강의에 적힌 의사코드(pseudo code)를 참고해 프로그램을 작성해보기로 했다.

1.3.1 초기 구현과 문제점 파악

<초기 계획>

• sma5(단기), sma20(중기), sma60(장기)로 나누어 각 기간별 가격 데이터 리스트 생성
• 리스트 비교를 통한 매매 신호 생성 (단기 vs 중기, 중기 vs 장기, 단기 vs 장기)

<발견된 문제점들>

• 투자/경제 개념 측면
  • 분봉 데이터 활용 시 SMA5 = 최근 5개 분봉 평균 (5일이 아님)
  • 스캘핑 vs 데이트레이딩 개념 혼동
  • 모의투자 API에서 일봉 데이터 미지원
• 코드 구조 측면
  • market_data.py 변수 미정의 상태에서 참조 시도
  • API 문자열 데이터의 숫자 변환 누락
  • candles[:20]으로는 SMA60 계산 불가
  • 매매 신호 생성 로직 미숙

1.3.2 문제 해결 과정

• 데이터 연동 및 타입 변환 문제

  내용: 과거 가격 데이터로 이동평균 계산하는데 일일이 코드를 지정해야함 
  분석: 과거 가격 데이터를 리스트로 만들어 moving_average.py로 넘기는 코드 누락
  해결: market_data.py에 strategies용 함수(get_historical_prices)를 만들어 API 문자열 데이터를 숫자로 변환 후 넘겨주기 가능

• SMA 단일 지표 한계

  내용: SMA만으로는 급격한 가격 변동에 늦은 반응, 단조로운 신호 생성
  분석: 단순이동평균은 모든 데이터에 동일 가중치 부여로 최신 변화 반영 지연
  해결: EMA(지수이동평균) 추가 구현으로 최신 데이터에 높은 가중치 부여, SMA/EMA 선택 가능한 통합 함수 개발

• 파라미터 관리 및 확장성 관련

  내용: 스캘핑/데이트레이딩 구분 없이 하드코딩된 설정, 모의투자 API 제약사항 미반영
  분석: 시간 프레임별 전략 차이 고려 부족, 일봉 데이터 미지원으로 데이트레이딩 테스트 불가
  해결: config.py 생성으로 전략별 설정 분리, 사용 불가능한 기능은 available: False로 표시하여 향후 확장 대비

1.3.3 최종 구현 결과

핵심 개선사항:

EMA 구현으로 급격한 가격 변동 대응력 향상 모듈화를 통한 코드 재사용성 확보 설정 파일 분리로 전략 관리 체계화 if name == "main" 패턴으로 직접 실행/import 구분

최종 파일 구조: AutomatedTrading/ ├── config.py # 전략별 설정 관리 ├── market_data.py # 데이터 수집 (공통) ├── strategies/ └── moving_average.py # SMA/EMA 통합 전략 이렇게 문제 발견 → 분석 → 해결 과정을 순서대로 정리하면 단순한 코드 나열이 아닌 문제 해결 능력을 보여주는 기술 블로그가 됩니다.

1.4. 백테스트

• 백테스트란? 과거 데이터로 매매 전략을 '시뮬레이션'하는 것
• 백테스트 흐름: 과거 데이터 -> 매매 신호 생성 -> 가상 거래 => 수익률 계산

1.4.1 백테스트 문제 해결 과정

• 파일 경로 및 모듈 import 이슈

  내용: strategies 폴더 내 파일에서 상위 디렉토리 토큰 파일 접근 불가
  분석: 실행 위치에 따른 상대경로 차이로 FileNotFoundError 발생  
  해결: os.path.join('..', 'access_token.txt') 및 동적 경로 설정 구현

• API 연속 조회 무한루프 위험

  내용: 데이터 수집 중 프로그램 응답 없음
  분석: 30개 제한 API에서 연속 조회 시 종료 조건 부족
  해결: max_requests 제한과 디버깅 메시지 추가로 안전장치 구현

• 횡보장에서의 의미없는 신호

  내용: 모든 이동평균값이 동일하여 HOLD 신호만 발생
  분석: 장마감 시간대 데이터로 주가 변동성 부족
  해결: 매개변수 조정(3, 8)

1.4.2. 백테스트 최종 구조

"""
백테스트란?
정의: 과거 데이터로 매매 전략을 '시뮬레이션'하는 것
흐름: 과거 데이터 -> 매매 신호 생성 -> 가상 거래 => 수익률 계산

<주요 함수별 역할>
backtest_strategy()
- 초기 자금 100만원, 신호마다 execute_trade() 호출, 거래기록 trades 리스트에 저장 후 최종 자산 & 수익률 계산
execute_trade()
- BUY: 현금으로 주식 최대한 매수
- SELL: 보유 주식 전량 매도
- HOLD: 아무것도 안함
calculate_performance()
- 거래 기록 분석 -> 성과지표 계산(승률, 손익비, 총 손익, 최대 연속 손실)
calculate_max_consecutive_loss():
- 연속 손실 계산
"""


from strategies.moving_average import generate_signals
from market_data import get_historical_prices

def backtest_strategy(initial_money, signals):
    """

    :param initial_money: 초기 자금
    :param signals: moving_average.py에서 나온 매매 신호들
    :return: 최종 자산, 수익률, 거래내역

    매매 신호 받아 수익률 계산하는 메인 함수
    """
   ...

def execute_trade(signal, current_cash, current_stocks, stock_price):
    """
    개별 거래 실행 함수(매수/매도)
    :param signal: BUY -> 현금으로 주식 최대한 매수, SELL -> 보유 주식 전량 매도
    :param current_cash:
    :param current_stocks:
    :param stock_price:
    :return:
    """
  ...

def calculate_performance(trades):
    """
    거래 결과 성과 분석
    :param trades: 총 수익률, 승률(=이익 거래 / 전체 거래), 손익비(=평균 이익 / 평균 손실), 최대 손실(연속 손실의 최대값)
    :return:
    """
 ...


def calculate_max_consecutive_loss(profits):
    """최대 연속 손실 계산"""


if __name__ == "__main__":
    # 삼성전자(005930) 데이터로 테스트 -> 변동성 작아 SK하이닉스(000660)로 교체
    stock_code = "000660"
    prices = get_historical_prices(stock_code, "minute", 100)

    print(f"전체 가격 데이터: {prices}")
    print(f"가격 변동 범위: {min(prices)} ~ {max(prices)}")

    if prices:
        print(f"수집된 데이터 개수: {len(prices)}")  # 추가
        print(f"첫 5개 가격: {prices[:5]}")  # 추가

        # SMA 백테스트
        print("=== SMA 백테스트 ===")
        sma_signals = generate_signals(prices, "SMA", 3, 8)  # 더 민감하게

        print(f"생성된 SMA 신호 개수: {len(sma_signals) if sma_signals else 0}")  # 추가
        if sma_signals:
            print(f"첫 3개 신호: {sma_signals[:3]}")  # 추가
            print(f"전체 SMA 신호들:")
            for i, signal in enumerate(sma_signals):
                print(f"{i + 1}: {signal['signal']} - SMA3: {signal['SMA3']:.1f}, SMA8: {signal['SMA8']:.1f}")

        if sma_signals:
            final_value, return_rate, trades = backtest_strategy(1000000, sma_signals)
            performance = calculate_performance(trades)

            print(f"최종 자산: {final_value:,}원")
            print(f"수익률: {return_rate:.2f}%")
            print(f"성과: {performance}")

        # EMA 백테스트
        print("\n=== EMA 백테스트 ===")
        ema_signals = generate_signals(prices, "EMA", 3, 8)

        if ema_signals:
            final_value, return_rate, trades = backtest_strategy(1000000, ema_signals)
            performance = calculate_performance(trades)

            print(f"최종 자산: {final_value:,}원")
            print(f"수익률: {return_rate:.2f}%")
            print(f"성과: {performance}")
    else:
        print("데이터 수집 실패")

1.5. 시각화

현재 SMA 3 vs 8 전략으로 삼성전자 데이터 분석 결과:

• 주가 패턴: 횡보 후 상승, 일시 하락, 재상승
• 신호 발생: 18번째 지점 SELL(데드크로스), 29번째 지점 BUY(골든크로스)
• 전략 한계: 후행성으로 인한 늦은 신호 발생 (최저점에서 매도, 상승 후 매수)

왜 코드 예제를 무작정 먼저 하냐면, 코드를 먼저 보고 나면 이 API를 활용한 주식 자동 매매 프로그램의 전체적인 숲을 먼저 볼 수 있기 때문이다.

어려워보여도 괜찮다! 어차피 실제 구현은 3. API 흐름에서 제대로 할 것이고, 지금은 그냥 한 줄씩 '아하 이때는 이런 코드가 쓰이는구나~'하고 가볍게 읽고 넘어가도 좋다. (●ˇ∀ˇ●)bb

그럼 이제 가보자고!!!

1. (무작정) 한국투자증권 API 코드 예제

자, 이제 한국투자증권의 API를 받아오는 기본 코드를 한번 작성해보자!

이전 글에서 공부한 대로 기본 설정 > REQUESTS > RESPONSE 순으로 코드를 적어보자.

<상황>
: 삼성전자 주가 데이터를 조회(GET)해서 10주를 매수해보는 것으로(POST)

기본설정

: HTTPS 통신의 기본인 requests를 불러오고 수많은 클라이언트 중에 '나'를 구별할 수 있는key,secret, token 등도 정의한다.

import requests

# 한국투자증권 API 기본 설정
BASE_URL = "https://openapi.koreainvestment.com:9443"
app_key = "YOUR_APP_KEY"
app_secret = "YOUR_APP_SECRET"
access_token = "YOUR_ACCESS_TOKEN"

Q1. key vs secret vs token 차이 A1. key로 기본 신원을 확인하고 secret으로 본인이 진짜 맞는지 확인하고 본인이 맞으면 실제 API 사용 권한인 token을 받는다.

Q2. URL에서 9443의 의미는? A2. 포트 번호를 의미. 포트 번호란 한 서버 컴퓨터에서 서비스를 구분하는 번호로 아파트의 '호수'같은 개념. 29443은 모의 투자 포트 번호를 의미. 참고로 알고있으면 좋은 포트 번호들은 아래에!

• 80: HTTP웹사이트(기본값)
• 443: HTTPS 웹사이트(기본값)
• 3306: MySQL 데이터베이스
• 8080: 개발용 웹서버

REQUEST

: REQUEST에는 크게 GET 요청과 POST요청이 있다. 이 프로젝트에서 GET 요청은 주가나 잔고 등의 데이터를 조회할 때 필요하며 POST 요청은 매수/매도 주문 등의 데이터를 보낼 때 필요하다. 각 메소드 별로 RESPONSE도 같이 적어본다.

GET

먼저 GET부터 작성해보자

# GET: 삼성전자주가 조회
# try: 조회 시도해보는데 except Exception as e: 에러가 나오는 경우도 예외처리 해줘야 함

try:
    # 현재 주가 조회 API 엔드포인트
    price_url = f"{BASE_URL}/uapi/domestic-stock/v1/quotations/inquire-price"  

    # 쿼리 파라미터(삼성전자: 005930)
    params = {
        "fid_cond_mrkt_div_code": "J",  # 시장 구분 (J: 주식)
        "fid_input_iscd": "005930"  # 종목코드(삼성전자)  
   }

   # GET 요청: 서버에서 주가 데이터 가져오기
   # res는 서버의 응답을 의미
   res = requests.get(price_url, headers=headers, params=params)

   # 응답 상태 확인
   if res.status_code == 200:  # 왜 200이야??
       data = res.json()
    current_price = data['output']['stck_prpr']  # 현재가
    change_rate = data['output']['prdy_ctrt']  # 전일대비 등락률
    print(f"삼성전자 현재가: {current_price}원")
    print(f"전일대비: {change_rate} %")
  else:
      print(f"주가 조회 실패: {res.status_code}")

except Exception as e:
    print(f"주가 조회 에러: {e}")

Q1. price_url에서 엔드포인트란? A1. 엔드포인트란 server에서 특정 기능을 담당하는 주소를 의미. /quotations/inquire-price는 주가를 조회해주는 곳을 의미

Q2. 쿼리 파라미터에서 J란? A2. 한국투자증권에서 임의로 정한 코드이다. - J: 주식(JSTOCK) - F: 선물(FUTURES) - O: 옵션(OPTIONS)

Q3. 쿼리 파라미터에서 fid와 isce의 의미? A3. 한국투자증권 API에서 사용하는 약어 - FID: Field ID(어떤 필드인지 구분) - ISCD: Issue Code(종목 코드 의미)

Q4. res.status_code가 200인 이유 A4. HTTP 상태를 나타내는 국제 표준 코드 - 200 = OK(성공) - 404 = Not Found(페이지 없음) - 500 = Server Error(서버 오류)

POST

그리고 이제 POST 요청도 작성해보자

# POST: 삼성전자 매수 주문
# GET과 마찬가지로 try-except으로 구성
try:
    # 매수 주문 API 엔드포인트
    # 엔드포인트란? 
    order_url = f"{BASE_URL}/uapi/domestic-stock/v1/trading/order-cash"

    # POST 요청용 헤더(거래 ID 추가)
    order_headers = headers.copy()
    order_headers["tr_id"] = "VTTC0802U"  # 매수 거래 ID

    # 주문 데이터(JSON 바디 내용)
    order_data = {
        "CANO": "계좌번호 앞 8자리"
        "ACNT_PRDT_CD": "01",  # 계좌상품코드
        "PDNO": "005930",  # 삼성전자 종목코드
        "ORD_DVSN": "01",  # 주문구분(01: 시장가)
        "ORD_QTY": "10",  # 주문수량 10주
        "ORD_UNPR": "0"  # 주문단가(시장가이므로 0)
    }

   # POST 요청: 서버에 매수 주문 데이터 보내기
   res = requests.post(order_url, headers=order_headers, json=order_data)

  # 응답 상태 확인
  if res.status_code == 200:
      data = res.json()
    # rt_cd: 한국투자증권 API 결과코드
    if data['rt_cd'] == '0':  # 성공
        order_no = data['output']['ODNO']
        print(f"매수 주문 성공!")
        print(f"주문번호: {order_no}")
        print(f"삼성전자 10주 시장가 매수 주문 완료")
   else:
           print(f"주문 실패: {data['msg1']}")
 else:
    print(f"주문 요청 실패: {res.status_code}")
except Exception as e:
    print(f"매수 주문 에러: {e}")

Q1. ORD_DVSN이 01인 이유 A1. 한국투자증권 API 주문 구분 코드이다. - 01: 시장가(현재 시세로 즉시 거래) - 02: 지정가(내가 원하는 가격으로 주문) - 03: 조건부 지정가 - 05: 장전 시간외

Q2. ORD_UNPR이 0인 이유 A2. 시장가는 지금 시세가 얼마든 상관없이 '즉시' 사는 것이기에 지정가와 달리 가격을 지정하지 않는다. 따라서 0을 입력한다.

2. API 개념

이렇게 우리는 어떻게 한국투자증권 API를 이용해 삼성전자 주가를 조회하고 매수까지 할지에 대해 전체 코드 흐름을 간단하게 알아보았다. 숲을 살펴보았으니 이제 이 API라는 나무에 대해 본격적으로 알아볼 시간!

API 개념

API는 Application Programming Interface의 약자로, 프로그램들의 접점이 되는 것을 의미한다. 예를 들어 여행 블로그 서비스를 출시하고 싶은데 지도를 구현하는 것이 힘드니까 Google Maps API를 쓰는 것이 나의 여행블로그 서비스와 Google Maps 간의 접점을 만드는 것이다.

한국투자증권 API

API 문서

이 API를 어떻게 활용할 수 있는지에 대해서는 파이썬 DOCS와 마찬가지로 API 문서에서 확인할 수 있다. 한국투자증권의 API문서를 확인해보니

• 시세 조회 -> GET
• 주문 -> POST
• 잔고 조회 및 체결 내역 조회 -> GET 방식으로 진행하는 것을 볼 수 있다.

3. API 흐름

그러면 이 API를 실제로 어떻게 사용할 수 있는지에 대해서는 일종의 작업이 필요하다. 자세한 내용은 아래와 같다.

• step1. 계좌 개설
• step2. 개발자로 등록
• step3. Access Token 발급
• step4. 코드로 API REQUEST 보내기

자, 이제 단계별로 살펴보자.

Step1. 계좌 개설

모바일 앱으로 회원가입을 진행했다. 앱에서 추천하는 대로 ISA + 국내/해외주식 + CMA 계좌로 개설했다. 개설하려니 계좌 종류도 선택하라고 해서 위 내용을 참고하여 필자는 투자 초보이므로 안전하게 RP형으로 선택 완료!(계좌종류는 API와 전혀 상관이 없다고 한다.)

일반 은행 계좌 개설과 달리 투자 계좌라서 그런지 위험성을 엄청 강조하고 그만큼 설문도 많아서 시간이 더 많이 드는 것 같았다. 회원가입하고 로그인하고 계좌개설까지 다 마쳤는데 알고 보니 1년 전에 가입해둔 계좌가 하나 있었다...처음이 아니었네 (머쓱🙄)

자동 매매 연결 계좌는 실제 계좌 아니면 모의 투자 계좌로 설정 가능한데 자동 매매인 만큼 예기치 못한 리스크가 크고 투자 감각을 익히기 위해서 모의 투자 계좌를 만들기로 했다.

트레이딩 탭 > 모의투자 안내 > 신청/재도전 에서 모의 투자 계좌를 만들고 이때 리그 구분은 국내 주식 1000만원 + 해외주식과 선물옵션을 선택하고 금액과 기간은 기존에 설정되어 있는대로 진행했다.

(모의투자 계좌 개설 완료!)

Step2. 개발자로 등록

• 목적: app key와 app secret을 발급받기 위함.

드디어 개발자 등록 단계이다...! 트레이딩 탭 > OpenAPI > KIS Developers > KIS Developers 서비스 신청/조회 (나중에 실전 투자 계좌도 따로 추가할 수 있으니 일단 모의 투자 계좌만 신청)

엇.. 근데 아까 모의 투자 계좌를 3개 만들었었는데(상시대회 국내주식, 상시대회 해외주식, 상시대회 선물옵션) 해외 취업을 원하지만 일단 기초 감각을 키우고 국내에서 경력을 쌓아야 하기에 상시대회 국내주식 모의 계좌로 API 신청했다. (KIS 개발자 신청하는데 '토큰이 존재하지 않습니다.'라는 오류창이 떴다. 단순 오류였고 새로운 탭에서 신청하니까 잘 됐다.)

개발자 신청 완료!

[중요] 앱키와 시크릿키는 절대 유출 및 도용되지 않도록 주의해야한다!!!

이제 Step3부터는 실제 한국 투자 증권의 API들을 불러올 것이다.

Step3. Access Token 발급

• 목적: app key(앱키)와 app secret(시크릿키)을 제시하면 한국투자증권은 자사 API를 쓸 수 있는 하루용 Access Token을 발급해준다.

API문서 중 접근토큰발급 관련이다. 기본 정보 - 요청(Header & Body) - 응답(Header & Body) - 예시로 구성되어 있다. 요청할 때 Body에서 appkey와 appsecret을 제시하면 응답 Body에서 access_token 토큰과 관련된 정보들을 제공한다. 확실히 처음에 코드 예제로 먼저 살펴본 내용이라 낯익은 단어들이 많아 이해하기 쉽다...!♪(´▽｀)

API의 기본 호출 구조

API 호출의 기본 구조:
1. requests 모듈 import
2. API를 불러오기 위한 기본 정보(BASE_URL, APPKEY, APPSECRET, ACCESS_TOKEN 등) 정리 =>신원확인  
3. url 설정(실전 or 모의 Domain)
4. headers = 서버에게 알려주는 내용
5. body = 서버에게 알려줄 때 함께 보낼 데이터 내용
6. try-except = 오류 처리 (네트워크 문제, 서버 오류 등)후 결과 출력

(참고: HTTP 메소드에는 GET, POST외에도 많지만 대부분의 증권 API 메소드가 GET, POST 위주라서 이 둘을 중심으로 정리한 내용)

위 내용을 참고해서 접근토큰발급 API 코드를 작성해보자. 함수 형식으로 정리하는 게 접근성과 보편성이 좋다고 해서def함수 키워드를 이용해 적어볼 것이다.

전체적인 파일 구조는 이러하다

AutomatedTrading/
├── auth.py
├── market_data.py
└── (auth.py 실행 후) access_token.txt  (토큰 문자열이 저장된 파일)

처음에는 코드잇 예제 코드처럼 딕셔너리 구조로 간단하게 코드를 작성하려고 했지만 코드 안정성(예외처리)과 재사용성(여러 번 호출 될 수 있음) 측면에서 함수로 정의하고 토큰은 파일로 저장하는 방식이 더 적합하다고 판단했다. (이 파일 저장방식이 실무에서도 많이 사용된다고 하기도 하고..!)

따라서 최종코드는 아래와 같다.

<auth.py>

# 이 파일은 한국 투자증권 '접근토큰발급'을 어떻게 발급받는지에 대한 실제 코드이다.
# 파일 저장 방식으로 구성

import requests

# 한국투자증권 기본 설정
BASE_URL = "https://openapivts.koreainvestment.com:29443"  # 모의 투자 Domain
APPKEY = "비밀1"
APPSECRET = "비밀2"

# 접근 토큰을 발급받아 파일로 저장
def get_access_token():
    url = f"{BASE_URL}/oauth2/tokenP"

    headers = {"Content-Type": "application/json"}
    body = {
        "grant_type": "client_credentials",
        "appkey": APPKEY,
        "appsecret": APPSECRET
    }

    try:
        res = requests.post(url, headers=headers, json=body)

        if res.status_code == 200:
            data = res.json()
            access_token = data.get('access_token')

            if access_token:
                # 토큰을 텍스트 파일로 저장
                with open('access_token.txt', 'w') as f:
                    f.write(access_token)

                print(f"=== 토큰 발급 및 저장 성공 ===")
                print(f"토큰: {access_token[:10]}...(이하 생략)")
                return access_token
            else:
                print(f"=== 토큰 발급 실패: 응답에 토큰이 없음 ===")
                return None
        else:
            print(f"=== 요청 실패: {res.status_code} ===")
            return None

    except Exception as e:
        print(f"오류 발생: {e}")
        return None

# auth.py을 실행했을 때만 토큰 발급
if __name__ == "__main__":
    get_access_token()

(마지막 if __name__ == "__main__": 코드에 대한 설명은 다음 Step4.에서 자세하게 다룬다.)

사실 여기서 한 발 더 나아가면

• res.status_code를 다양하게 나누어 예외처리를 하거나(e.g. 400: 요청 오류, 401: 인증 실패 등)
• except의 경우의 수를 다양하게 처리 해주는 게 더 나으나(e.g., except requests.exceptions.Timeout: 요청시간 초과, except requests.exceptions.ConnectionError: 연결 오류 등)

지금은 최소한의 필수 코드만 구현하는 데 집중했다 :>

Step4. 코드로 API REQUEST 보내기

• 이제 API 문서에 적힌 내용대로 다양한 기능을 쓸 수 있다(e.g, 삼성 전자 현재가 데이터 받아오기, 잔고 조회, 주식 거래 내역 등)

이번에 해볼 것은 [국내주식] 기본 시세 > 주식당일분봉조회 이다.

접근 토큰 발급 API 파일보다 내용이 훨씬 많지만 차근차근 작성해보자 (๑•̀ㅂ•́)و✧

코드 흐름은 다음과 같다.

step1. def load_token(): 으로 access_token.txt에 저장된 토큰 불러오기 
step2. def get_stock_price(stock_code):로 주식당일 분봉 조회하기
step3. 전체 코드 실행

<market_data.py>

의 최종 코드는 두 버전으로 나누었다.

• Clean ver.에는 코드를 이해하는 데 최소한의 주석만 남겨놓았고
• Full ver.에는 코드를 공부하면서 기록한 모든 주석 내용을 포함했다.

• 먼저 Clean ver.

  # 이 파일은 한국 투자증권 '주식당일분봉조회' API를 어떻게 발급받는지에 대한 코드이다.
  # Method: GET
  import requests
  

한국투자증권 기본 설정

BASE_URL = "https://openapivts.koreainvestment.com:29443" APPKEY = "비밀1" APPSECRET = "비밀2"

저장된 토큰 파일 읽어오는 함수

def load_token(): print("토큰 읽어오는 중 ...") try: with open('access_token.txt', 'r') as f: token = f.read().strip() return token except FileNotFoundError: print("토큰 파일이 없습니다. auth.py 먼저 실행하세요!") return None except Exception as e: print(f"토큰 읽기 오류: {e}") return None

주식 분봉 데이터 조회하는 함수

def get_stock_price(stock_code): print("get_stock_price 함수 시작")

# 저장된 토큰 불러오기
access_token = load_token()
if not access_token:
    print("토큰 없어서 함수 종료~")
    return

print("저장된 토큰 확인 완료")
# 기본 정보 URL
url = f"{BASE_URL}/uapi/domestic-stock/v1/quotations/inquire-time-itemchartprice"

# REQUEST 부분
headers = {
    "content-type": "application/json; charset=utf-8",
    "authorization": f"Bearer {access_token}",
    "appkey": APPKEY,
    "appsecret": APPSECRET,
    "tr_id": "FHKST03010200",  
    "custtype": "P" ,
}

params = {
    "FID_COND_MRKT_DIV_CODE": "J",
    "FID_INPUT_ISCD": stock_code, 
    "FID_INPUT_HOUR_1": "100000", 
    "FID_PW_DATA_INCU_YN": "Y",  
    "FID_ETC_CLS_CODE": "00" 
}

try:
    res = requests.get(url, headers=headers, params=params)
    # 응답 상태 확인
    if res.status_code == 200:
        print(f"응답 상태 코드: {res.status_code}")
        data = res.json()

        # 응답 구조
        if data.get('rt_cd') == '0':  # 한투 API 성공코드
            # output1: 종목 현재 상태(Object)
            stock_info = data.get('output1', {})
            stock_name = stock_info.get('hts_kor_isnm', 'N/A')  # 종목명
            current_price = stock_info.get('stck_prpr', 'N/A')  # 현재가
            current_rate = stock_info.get('prdy_ctrt', 'N/A')  # 등락률

            print(f"=== {stock_name} 현재 정보 ===")
            print(f"현재가: {current_price}원, 등락률: {current_rate}%")

            # output2: 분봉 데이터(Object Array)
            candles = data.get('output2', [])

            if candles:
                print(f"=== {stock_name} 분봉 데이터 ===")
                for i, candle in enumerate(candles[:5]):
                    date = candle.get('stck_bsop_date', 'N/A')  # 주식 영업일자
                    time = candle.get('stck_cntg_hour', 'N/A')  # 주식 체결시간
                    price = candle.get('stck_prpr', 'N/A')  # 주식 현재가
                    volume = candle.get('cntg_vol', 'N/A')  # 체결 거래량
                    print(f"{i+1}.{date}{time} - 가격: {price}원, 거래량: {volume}")
            else:
               print("분봉 데이터가 없습니다.")
        else:
           print(f"API 오류: {data.get('msg1', '알 수 없는 오류')}")
    else:  
       print(f"HTTP 요청 실패: {res.status_code}")
       print(f"에러 내용: {res.text}")

except Exception as e:  
   print(f"요청 중 네트워크/코드 오류 발생: {e}")

if name == "main": print("프로그램 시작") get_stock_price("005930") print("프로그램 종료")

- 그 다음 **Full ver.**

이 파일은 한국 투자증권 '주식당일분봉조회' API를 어떻게 발급받는지에 대한 코드이다.

Method: GET

import requests

한국투자증권 기본 설정

BASE_URL = "https://openapivts.koreainvestment.com:29443" APPKEY = "비밀1" APPSECRET = "비밀2"

저장된 토큰 파일 읽어오는 함수

def load_token(): print("토큰 읽어오는 중 ...") try: with open('access_token.txt', 'r') as f: token = f.read().strip() return token except FileNotFoundError: print("토큰 파일이 없습니다. auth.py 먼저 실행하세요!") return None except Exception as e: print(f"토큰 읽기 오류: {e}") return None

주식 분봉 데이터 조회하는 함수

def get_stock_price(stock_code): print("get_stock_price 함수 시작")

# 저장된 토큰 불러오기
access_token = load_token()
if not access_token:
    print("토큰 없어서 함수 종료~")
    return

print("저장된 토큰 확인 완료")
# 기본 정보 URL
url = f"{BASE_URL}/uapi/domestic-stock/v1/quotations/inquire-time-itemchartprice"

# REQUEST 부분
headers = {
    "content-type": "application/json; charset=utf-8",
    "authorization": f"Bearer {access_token}",
    "appkey": APPKEY,
    "appsecret": APPSECRET,
    # "personalseckey": , # 선택사항 - 개인키 없으면 생략
    "tr_id": "FHKST03010200",  # transaction 거래 식별자_당일 분봉조회 API 고유코드
    # "tr_cont": , # 연속조회 - 처음엔 공백
    "custtype": "P" ,
    # 아래 항목들은 모의 투자에서 보통 생략 가능
    # "seq_no": ,
    # "mac_address": ,
    # "phone_number": ,
    # "ip_addr":,
    # "gt_uid"
}

# GET 요청에서는 POST와 달리 데이터를 URL의 쿼리 파라미터로 전송
params = {
    "FID_COND_MRKT_DIV_CODE": "J",  # Field ID 국내주식
    "FID_INPUT_ISCD": stock_code, # Issue Code 종목코드
    "FID_INPUT_HOUR_1": "100000", # 조회할 시간(HHMMSS): 9시 1분~10시 00분까지
    "FID_PW_DATA_INCU_YN": "Y",  # Previous Data Include
    "FID_ETC_CLS_CODE": "00"  # Et Cetera Class 기타 구분 코드. 기본값 00
}

Codeit

짧고 간단하나 안정성이 매우 중요한 실무에서 이러한 코드는 사용 x

try:

res = requests.get(url, headers=headers, params=params)

data = res.json()

print(data["output1"]["hts_kor_isnm"]) # HTS 한글 종목명

for item in data["output2"]:

print(f"시간: {item['stck_bsop_date']} {item['stck_cntg_hour']} 가격:{item['stck_prpr']}")

except Exception as e:

print(e)

try:
    res = requests.get(url, headers=headers, params=params)
    # 응답 상태 확인
    if res.status_code == 200:
        print(f"응답 상태 코드: {res.status_code}")
        data = res.json()

        # 응답 구조
        if data.get('rt_cd') == '0':  # 한투 API 성공코드
            # output1: 종목 현재 상태(Object)
            stock_info = data.get('output1', {})
            stock_name = stock_info.get('hts_kor_isnm', 'N/A')  # 종목명
            current_price = stock_info.get('stck_prpr', 'N/A')  # 현재가
            current_rate = stock_info.get('prdy_ctrt', 'N/A')  # 등락률

            print(f"=== {stock_name} 현재 정보 ===")
            print(f"현재가: {current_price}원, 등락률: {current_rate}%")

            # output2: 분봉 데이터(Object Array)
            candles = data.get('output2', [])

            if candles:
                print(f"=== {stock_name} 분봉 데이터 ===")
                for i, candle in enumerate(candles[:5]):
                    date = candle.get('stck_bsop_date', 'N/A')  # 주식 영업일자
                    time = candle.get('stck_cntg_hour', 'N/A')  # 주식 체결시간
                    price = candle.get('stck_prpr', 'N/A')  # 주식 현재가
                    volume = candle.get('cntg_vol', 'N/A')  # 체결 거래량
                    print(f"{i+1}.{date}{time} - 가격: {price}원, 거래량: {volume}")
            else:
               print("분봉 데이터가 없습니다.")
        else:
           print(f"API 오류: {data.get('msg1', '알 수 없는 오류')}")
    else:  # 통신 o 정보 전달 x
       print(f"HTTP 요청 실패: {res.status_code}")
       print(f"에러 내용: {res.text}")

except Exception as e:  # 통신 x
   print(f"요청 중 네트워크/코드 오류 발생: {e}")

if name == "main": print("프로그램 시작") get_stock_price("005930") # 만약 종목을 바꾸고 싶으면 이 get_stock_price 파라미터 숫자만 바꿔주면 됨! print("프로그램 종료")

![](https://velog.velcdn.com/images/sujikim-hattoo/post/240306b3-0419-4386-ba44-8b22e338b58b/image.png)

> 여기서 `if __name__ == "__main__"`란?
: 파이썬의 관례적인 코드 패턴으로 해당 파일을 '직접 '실행할 때만 동작하게 한다(일종의 제어 목적). 이 문구가 없으면 다른 파일에서 `import`할 때 원하지 않는 코드가 자동 실행되어 문제가 발생한다.

> e.g., 

market_data.py (if문 없이 작성)

def get_stock_price(code): # API 호출 로직 get_stock_price("035720") # 카카오 조회하는 것으로 코드 설정

--------

main.py에서

import market_data # 이 순간 카카오 API 자동 호출됨 market_data.get_stock_price("005930") # 삼성전자 조회

결과: 카카오 API + 삼성전자 API 총 2번 호출
문제점: 불필요한 API 호출(시간 지연), API 서버 부하 증가 등

---
---

╭ ◜◝ ͡ ◜◝ ͡ ◜◝ ͡ ◜◝ ╮ 후... 드디어 다했다..! ╰ ◟◞ ͜ ◟ ͜ ◟◞ ͜ ◟ ͜ ◟◞◟◞╯ ⠀⠀⠀⠀O ⠀⠀⠀⠀⠀° 〃o　 ()＿() ‎⊂⌒ （´ ^ ﻌ ^） ヽ_っ＿/￣￣￣/ 　 　 ＼/＿＿＿/

API 공부는 처음이라 코드를 작성하고 공부하는데 생각보다 많은 시간이 걸렸지만...
Claude 덕분에 전반적으로 코드를 보다 빨리 이해할 수 있었다.
다음에는 투자의 꽃, 투자 전략에 대해 다뤄보겠뜨아!!!

아래 내용은 코드잇의 'Python 프로젝트: 주식 자동 매매' 토픽을 공부하며 작성한 내용입니다. 토픽 링크: https://www.codeit.kr/topics/project-python-automated-trading

흠... 주식을 자동으로 매매하는 프로그램을 만들기 위해서는 무엇이 필요할까?

주식에 대해 아무것도 모르는 사람이라도 주식을 사기 위해서는 해당 회사의 '데이터'가 필요하다는 것은 알고 있다! 그 회사의 전날 주가는 어떠했고, 그동안의 주가 흐름은 어땠으며... 등 말이다.

그렇다면 이러한 투자 관련 정보들을 가져올 수 있는 데이터 원천이 있어야 프로그래밍을 할 수 있을 텐데...!

자, 먼저 그곳이 어디든 우리가 어떠한 데이터를 흔히 '끌어올' 때는 API라는 것을 쓴다. AI 기능을 사용하고 싶을 때 ChatGPT API를 쓰는 것처럼 이 API 개념을 이해하고 잘 활용하기 위해서는 필수적으로 이해해야 하는 것이 있다.

바로 인터넷의 기본 작동 방식!

인터넷

일단 인터넷이란 무엇일까? 퍼플렉시티에게 물어봤다.

Q. Internet 어원
A. 인터넷(Internet)은 서로 다른 네트워크들을 연결하는 기술 개념에서 유래된 말로, ‘네트워크의 네트워크’를 지향하는 의도에서 처음 명명되었다는 점이 특징입니다 

그렇다! 서로 다른 네트워크들을 연결한다는 것인데...

그렇다면 누구와 누구를 연결하는 것이고 왜 연결하는 것일까? 이것을 이해하기 위해서는 인터넷의 핵심 멤버를 알아야 한다.

인터넷의 핵심 구성요소: 서버, 클라이언트 그리고 HTTP

서버

: 정보를 주는 쪽.

클라이언트

: 정보를 요청해 정보를 받는 쪽.

-> 여기서 정보는 '데이터'이다. 즉, 클라이언트가 서버에게 특정 '데이터'를 요청하면 서버는 클라이언트에게 '데이터'를 제공하는 아주 단순한 구조이다! 예를 들어 내가 노트북을 켜고 유튜브에서 '스캘핑'영상을 검색했을 때 서버-클라이언트 흐름은 다음과 같다.

[클라이언트] 내 노트북 브라우저
     ↓ (HTTP 요청)
"youtube.com에서 '스캘핑' 영상 목록 주세요"
     ↓
[서버] 유튜브 서버
     ↓ (HTTP 응답)  
"스캘핑 관련 영상 데이터 (제목, 썸네일, URL 등)"
     ↓
[클라이언트] 내 노트북에서 영상 목록 화면에 표시

이렇게 표현하니 얼마나 이해하기 쉬운가!

그런데 컴퓨터끼리도 이렇게 서로 '한국어'로 친근하게

• 컴퓨터 1: 목록 주세요!
• 컴퓨터 2: 네네 목록 여기 있어요..~~ 할 수는 없지 않을까...?

그래서 등장한 것이 바로 HTTP

HTTP

: 인터넷에서 컴퓨터끼리 대화하는 언어이자 소통방식. 흔히 URL 가장 앞에 https://가 쓰이는 이유가 있는 것이다...!

이 HTTP를 써서 클라이언트는 서버에게 데이터 요청, 즉 Request를 하고 서버는 클라이언트의 요청을 받아 데이터 제공, 즉 Response를 할 수 있는 것이다.

자 이렇게 서버-클라이언트의 대화를 실제로 확인할 수 있는 방법이 있다.

Windows: F12 키
macOS: Cmd + Option + I

Network 탭> 아래 Name에 아무거나 클릭하면 (잘 모르겠지만 일단 개인정보 관련되어 보이는 건 다 지워봤다...)

Headers탭에는 크게 1) General 2) Response Headers 3) Request Headers 로 구성되어있는 것을 볼 수 있다.

각 목차별 눈여겨 볼 것들과 간단한 설명도 같이 적어보자면 1) General

• Request URL(요청하는 구체적인 주소. https:// 뒤에 붙는 경로와 쿼리 파라미터가 포함됨)
• Request Method(요청하는 방법을 의미. e.g., GET: 데이터 가져와, POST: 데이터 보내줄게 등)

2) Response Headers

• Content-Type(application/json 으로 되어있는데 그렇다. 데이터는 모두 JSON 형태로 받아온다.)

  Q. JSON형태란? A. HTTP에서 쓰이는 표준 데이터 형식을 의미하며 여러개의 중괄호로 구성된 딕셔너리 형식으로 되어있다.

3) Request Headers

• Content-Type(마찬가지로 application/json으로 되어있다.)

그래서 위 정보들로 서버-클라이언트 정보 흐름을 조금 더 구체화해본다면 ...

[클라이언트] 내 노트북 브라우저
     ↓ (HTTP Request)
"youtube.com에서 '스캘핑' 영상 목록 주세요" (GET 메소드)
     ↓
[서버] 유튜브 서버
     ↓ (HTTP Response)  
"스캘핑 관련 영상 데이터 (제목, 썸네일, URL 등)"
(Header: 응답 정보 / Body: JSON 형태로 작성된 스캘핑 관련 영상 데이터)
     ↓
[클라이언트] 내 노트북에서 영상 목록 화면에 표시

이 정도로 네트워크에 대한 기본 지식을 쌓았으면 본격적으로 코딩을 해볼 차례!(다음 글에서 계속됩니다!)

두다다다다다다다
　(∩`・ω・)
＿/_ミつ/￣￣￣/
　　＼/＿＿＿/

위 링크에서 YOLO의 장점 내용을 설명할 때 잠깐 언급되었던 컴퓨터 비전의 'mAP'..에 대해 알아보자..!

정의

: mAP(mean Average Precision)는 객체 감지 모델의 성능을 측정하는 대표 지표

계산 과정

Step1. IoU기준 설정(예측 박스와 실제 박스 겹침 정도. 보통 0.5 이상) Step2. class별 AP 계산(e.g., 자동차, 사람, 강아지 등 각 클래스 마다 정확도 측정) Step3. 전체 평균(모든 class의 AP 평균내어 하나의 mAP 점수 도출)

mAP는 단순한 정밀도의 평균이다 (x) mAP는 Precision-Recall 곡선의 면적이다 (o)

* AP란? Average Precision의 줄임말로 각 class별로 Precision-Recall 곡선 아래 면적을 계산한 값 ** Precision-Recall 곡선이란? 모델이 얼마나 정확하게 예측했는지(Precision)와 실제 객체를 얼마나 빠뜨리지 않고 찾았는지(Recall)을 나타내는 두 지표. 이 두 지표의 관계를 그래프로 나타낸 곡선

객체 인식에서의 활용:

mAP 특징

• 종합 평가 지표(정확도와 재현율 모두 고려)
• 클래스 균형(모든 객체 클래스 성능 공평하게 평가함)
• 비교 가능(서로 다른 모델 간 객관적 성능 비교 가능)
• 임계값 독립적(특정 임계값 의존x. 안정적o)

그 결과!

• 거의 모든 객체 감지 모델(e.g., YOLO, R-CNN, SSD 등)등에서 mAP로 성능 비교
• 대표 데이터셋(e.g., PASCAL VOC, COCO 등)에서도 공식 평가 지표로 사용

한 줄 요약 : mAP는 객체 감지 모델 성능을 측정하는 대표 펴가지표로 정확하고 안정적이기에 대부분의 객제 감지 모델과 데이터셋에서도 사용된다

You Only Look Once

한 번밖에 볼 수 없다 즉, 단 한 번만 보면 된다는 뜻의 모델. 과연 이 모델이 뜻하는 '단 한번'이란 무엇일까?

역사

• 먼저 이 YOLO는 2015년 JosephRedmon과 Ali Farhadi가 개발한 Darknet 프레임워크에서 처음 소개되었다. 지금은 2025년 2월에 출시된 YOLOv12가 최신 버전이며 계속해서 발전해왔다.

정의

• 객체 감지(Object Detection)분야의 대표적인 모델로,'실시간(real-time)' 감지가 주목적이다. 실시간으로 객체 위치를 찾고(Localization) + 동시에 그것이 무엇인지 분류하는(Classification) 작업이 실시간으로 이루어진다는 것이다.

작동 방식

• 바로 여기서 단 한 번의 순전파로 모든 작업을 완료한다. 전체 이미지를 한 번에처리하여 위치 감지와 분류를 동시에 수행하는 한 단계의 작업 <-> R-CNN: 이미지에서 관심 영역(RoI)을 먼저 찾은 뒤 그 다음 각 영역마다 분류 작업을 수행하는 두 단계의 작업

특징

• 전체 이미지에 단일 신경망 적용

• 신경망 예측을 위해 단 한 번의 전방 전파 통과만 필요 <-> R-CNN: 단일 이미지 수천 번의 통과 필요

• 실시간 처리능력 -> 빠르게 지나가는 차량 감지 / 교통 패턴 분석/산불 위험 감지/동물 식별/위험 행동 모니터링 등 다양한 분야에서 활용됨

장점

• 빠름 -> 초당 수십 프레임의 비디오 처리가 가능해서 실시간 추적에도 유용하다.

• 지속적인 정확도 향상 -> 버전업마다 개선 중(e.g., YOLO11은 YOLOv8m대비 22% 적은 파라미터로 더 높은 mAP 달성) mAP란? mean Average Precision의 줄임말로 객체 감지 정확도를 측정하는 대표 지표를 의미

• 우수한 접근성 -> 오픈소스여서 접근성과 활용성이 뛰어나고 간단한 API로도 쉽게 사용이 가능하다.

한 줄 정리 : YOLO 는 단 한번의 순전파로 실시간 객체 감지 분야에 혁신을 가져와 이미지의 처리 속도와 정확도를 높였습니다.

참고 https://en.wikipedia.org/wiki/You_Only_Look_Once#cite_note-:2-1 https://blog.roboflow.com/guide-to-yolo-models/

https://youtu.be/VLiTTQtQcr4?feature=shared 위 영상으로 '어? 스캘핑? 재밌어보이는데?'라는 생각이 생겼다.

어떤 것이든 오래 길게 끄는 것을 싫어하는 나로서는 장투보다는 단타와 스캘핑이 제일 잘 맞는 것 같았다. (물론 한 번도 해본 적은 없다. 끌끌)

그런데 문제가 있다. 바로 . . . 나는 주식에 대해 '아무것도' 모른다는 것!

대차대조표가 대변과 차변으로 이루어져 있다. 대변은 부채이고 차변은 자산?자본?이고 또..ROI가 중요하다는 것..?

자산과 자본의 차이도 제대로 설명하지 못하는 사람인데 갑자기 그런 생각이 들었다.

투자에도 코딩에도 관심있으니 한번 만들어보는 게 좋지 않겠어..?

항상 내가 프로그래밍 공부에 뛰어들 때마다 주변의 업계(?)선배들이 일단 뭐라도 만들어봐라고 했으니,,!

이렇게 나의 프로젝트는 시작됐다. 주식과 프로그래밍 어느 하나 제대로 모르는 비전공자인 내가! 주식 자동 매매 프로그램을 만들게 되었다는 것 ( •̀ ω •́ )✧

먼저 AI한테 자문을 구해보았다.

(노란색: 내가 '최소한으로' 공부해야하는 것) (빨간색: 개인 AI 자동 매매 프로그램 개발의 한계 & 스캘핑/단타의 단점)

=> 한 마디로 비전공자 혼자 주식 자동 매매 프로그램을 만들기까지 시간과 노력이 너무 많이 들고 들인 투자 대비 결과도 매우 불확실하다는 것...╯︿╰

일단 지금은 완성도 높은 자동 매매 로직(실시간 매매 및 리스크 관리까지 해주는...)구축보다는 투자 판단 보조 목적으로 분석하고 추천해주는 툴을 만드는 것이 좋아보인다.

전체적인 프로그램을 만들기 전에 앞서서 책이나 강의를 보고 한번 슈슉 만들어보는 게 좋겠다고 생각하던 찰나 코드잇에서 아래와 같은 강의를 발견하게 되었다! https://www.codeit.kr/topics/project-python-automated-trading

오오 원래의 목표대로 주식 자동 매매 프로그래밍을 한 번 해볼 수 있으니 모르는 개념도 공부하며 전체적인 프로그래밍 흐름도 파악하기에 좋아보였다. ( ￣▽￣)bb

그래서 위 목차대로 일단 한 번 공부해보기로 도전!

딥러닝, 특히 이미지 모델에서는 이러한 전처리가 필요 없을까?

...

있다! 이미지 모델 전처리 과정은 크게 다음과 같이 진행된다.

이미지 로드 -> (선택) Gray scale => 이미지 리사이징 -> 이미지 정규화 -> 이미지 노이즈 처리 -> 이미지 정규화

그 중에서도 이미지 크기와 처리 면에서 중요하게 다뤄지는 리사이징(Resizing)과 정규화(Normalization).

'왜' 위 두 과정이 모델에 이미지 입력전 필요한지 살펴보겠다.

(* 실험환경: 코랩) (** 실험 이미지 출처)

1. 리사이징(Resizing)

• 뜻:크기를 축소하거나 이미지 크기를 통일시키는 것

• 이유:

  • 리사이징 전: 이미지 크기가 크면 그만큼 GPU 메모리를 많이 차지.(변수량 많아져 처리속도가 많인 느려짐)
  • 리사이징 후: 같은 크기가 되어 한 번에 여러 이미지 처리 가능 & 작은 크기일수록 빠른 연산 가능 => 이미지 처리 양과 속도에 영향

• 방법 1) 픽셀 단위

  • 단순:cv2.resize(image,(width, height))
  • 보간: cv2.resize(image, (width, height)), interpolation=cv2.INTER_AREA)(각 픽셀에 연결지점을 어떻게 연결시켜줄지)

  2) 이미지 높낮이: 실제 이미지 배열에 직접 접근

  • x,y,width,height 지정 -> image_resized[y:y+height, x:x+width]

Q. cv2. 란? A. OpenCV(Open Source Computer Vision Library)의 파이썬 버전으로 이미지 처리를 위한 가장 널리 사용되는 라이브러리이다. 이미지를 BGR(Blue-Green-Red)순으로 읽는다.

Q. 사이즈는 어떻게 결정? A. 보통 input 이미지 크기에 맞춰 결정(e.g. ResNet 224x224, YOLO 608x608 등)

Q. 사이즈를 줄이는 과정에서 정보 손실이 일어나지 않는지?
A. 일어난다. 하지만 '핵심 특징'만 추출하는 것이 목표이므로 적절한 크기 조정으로 조정해도 괜찮다. (여기서 핵심특징 예시는?)

• 기대 효과: 계산 속도 상승, 성능 개선

2. 정규화(Normalization)

• 뜻: 픽셀 값의 범위를 일정하게 맞춰주는 것

• 이유

  • 정규화 전: 픽셀 값 범위는 0~255. 이 큰 값들이 모델 학습에 방해

  • 정규화 후: 픽셀 값 범위를 작게 하여 경사하강법이 안정적으로 동작하게 하고 적절한 분포로 활성화 함수가 효과적으로 작동하게 한다. 결과적으로는 학습 속도 향상!

    Q. 정규화를 하면 픽셀값 범위를 줄이는 것인데 이미지 변화가 생기는 것은 아닌지? A. => 정규화는 정보 손실 없이 학습 최적화를 위해 단순히 숫자 범위만 바꾸는 과정.(like 온도를 섭씨 -> 화씨로 바꾸는 것 처럼. 실제 의미는 동일한 것!)

• 방법
  • <밝기와 대비가 다양한 이미지> Min-Max 정규화
    • <단순한 전처리, Grayscale 이미지> Mean 정규화
    • <Scale에 민감한 모델> Z-score 정규화
    • <수치가 큰 이미지 데이터> Decimal 정규화
  • <이미지 유사도 분석이나 클러스터링> L2 정규화
  • <이상치가 많은 데이터> Robust 정규화
    • 기대 효과: 더 빠르고 안정적인 수렴

기술 면접 대비 한 줄 요약: 리사이징은 이미지 크기를 통일 & 메모리 절약 => 더 효율적인 배치 처리 가능하게 함 / 정규화는 픽셀값 범위를 조정 -> 모델 학습을 안정화하고 수렴 속도를 높임

참고 이미지 전처리 - 리사이징1 이미지 전처리 - 리사이징2 이미지 전처리 - 정규화

여러분은 지금 X-ray 이미지로 폐렴인지 아니면 정상인지 분류 작업을 진행하고 있습니다.

이전에 이미지의 노이즈를 최소화하는 작업의 평가 함수는 단순한 오차 계산이었다면의료 이미지 분류 작업은 생명과 직결되어 있어서 단순한 오차 값으로 계산을 할 수가 없는데요.

그러기 위해 알아야 할 핵심 개념이 바로 혼동행렬과 핵심 평가 지표입니다

혼동행렬

모든 평가의 기본인 Consufion Matrix(혼동행렬)은 다음과 같이 생겼습니다.

혼동행렬의 기본 용어 4가지를 정리해보면 다음과 같습니다!

• TP (True Positive): 폐렴을 폐렴으로 맞춤 = 95개
• TN (True Negative): 정상을 정상으로 맞춤 = 90개
• FP (False Positive): 정상을 폐렴으로 잘못 진단 = 5개 (1종 오류)
• FN (False Negative): 폐렴을 정상으로 잘못 진단 = 10개 (2종 오류) ⚠️ 위험!

표를 용어들로 채워본다면 아래와 같겠네요!

핵심 평가지표(5가지)

그리고 이 혼동행렬을 통해 아래와 같이 주요 평가지표들을 계산하는 것이 더욱 중요합니다. 주요 평가 지표 5가지의 정의와 계산하는 방식에 대해 차례대로 알아보겠습니다!

1. Accuracy (정확도)

• 의미: 전체 예측 중 맞춘 비율
• 공식: (TP + TN) / (TP + TN + FP + FN) = 총 사람수를 True합(정상은 정상으로, 폐렴은 폐렴으로 예측한 수)으로 나눠
• 예시: (95 + 90) / (95 + 90 + 5 + 10) = 185/200 = 92.5%
• 문제점: 데이터 불균형 시 잘못된 신호 줄 수 있음

2. Precision (정밀도)

• 의미: 폐렴이라고 예측한 것 중에서 실제로 폐렴인 비율
• 공식: TP / (TP + FP) = 폐렴으로 예측하고 또 실제 폐렴이기도 한 사람 수를 모델이 폐렴으로 예측한 총 사람 수로 나눠
• 예시: 95 / (95 + 5) = 95%
• 해석: 모델이 폐렴이라고 하면 95% 확률로 진짜 폐렴

3. Recall (재현율, Sensitivity)

• 의미: 실제 폐렴 환자 중에서 모델이 폐렴이라고 예측한 비율
• 공식: TP / (TP + FN) = 폐렴으로 예측하고 또 실제 폐렴이기도 한 사람 수를 총 실제 폐렴 환자 수로 나눠
• 예시: 95 / (95 + 10) = 90.5%
• 해석: 폐렴 환자 100명 중 약 90명을 찾아냄
• 의료에서 중요: 놓치면 안 되는 질병일 때 핵심!

4. F1-Score

• 의미: 2.Precision과 3.Recall의 조화평균
• 공식: 2 × (Precision × Recall) / (Precision + Recall)
• 예시: 2 × (0.95 × 0.905) / (0.95 + 0.905) = 92.7%
• 특징: 두 지표 균형을 맞추고 싶을 때 사용

5. Specificity (특이도)

• 의미: 실제 정상인 중에서 모델이 정상으로 판단한 비율. 위 다른 4가지 지표들에 비해 크게 중요하게 다뤄지지는 않음
• 공식: TN / (TN + FP)
• 예시: 90 / (90 + 5) = 94.7%
• 해석: 정상인 100명 중 95명을 정상으로 판단

평가지표 해석

위 평가 지표를 토대로 결과를 정리해보면 아래와 같습니다.

📊 평가 지표: • Accuracy: 185/200 = 92.5% "전체적으로 잘 맞춤" • Precision: 95/100 = 95% "폐렴이라고 하면 대부분 맞음"
• Recall: 95/105 = 90.5% "폐렴 환자 10명을 놓쳤음" ⚠️ • F1-Score: 92.7% "전반적으로 균형잡힌 성능"

내용 정리

실제 의료현장에서는 어떤 케이스가 제일 위험할까요...? 바로

실제 폐렴환자를 정상으로 오진하는 것

입니다..!

그렇기 때문에 평가지표 중에서도

Recall

이 가장 중요하다고 할 수 있죠.

-> 의료 이미지 분류 모델에서는 Recall을 최대한 높여 FN을 줄이는 것이 중요하고 Recall과 트레이드 오프 관계인 Precision은 조금 낮아져도 괜찮습니다 :)

(c.f. Recall과 Precision 사이의 트레이드 오프 관계가 생기는 이유는 조금이라도 이상하면 다 폐렴으로 진단해야 높아지는 Recall값과 보다 폐렴 진단 기준을 엄격하게 조정해야 높아지는 Precision 값의 성격은 서로 다르기 때문입니다. 어려운 말로 임계값 조정이 Recall과 Precision 값에 서로 반대 영향을 주기 때문이라고 정리할 수 있습니다.)

그래서 실제 의료 AI 모델링을 할 때는 다음과 같은 기준을 세우는 것을 권장합니다

• Recall 95% 이상(최우선)
• Precision 80% 이상
• (가능하면 전체적인 Accuracy도 높이는 방향으로)

Recall을 높이려면 임계값 조정이나 클래스 가중치 설정이 필요하고 손실함수에서 FN(False Negative; 폐렴인데 정상으로 예측)에 더 큰 페널티를 주는 것도 효과적이겠죠! 이번 글은 전체적인 개념 설명이기때문에 방법론은 이쯤에서 마무리 하겠습니다.

중요한 점은 의료 AI 분야에서는 놓치는 것이 잘못 찾는 것보다 훨~씬 더 위험하다는 점!!을 항상 염두에 두어야합니다!!!!

 This writing is provided in English first, followed by Korean.
이 글은 영어 -> 한국어 순으로 작성되어 있습니다.

An Autoencoder

• an unsupervised neural network
• that learns to compress (encode) data into a low-dimensional representation
• and then reconstruct (decode) it back to its original form. - Its primary goal is to learn the most essential features of the data, captured in a compressed "latent space."

1. Introduction

1.1. Definition

An Autoencoder is an unsupervised neural network that learns to compress (encode) data into a low-dimensional representation and then reconstruct (decode) it back to its original form. Its primary goal is to learn the most essential features of the data, captured in a compressed "latent space," by training the network to reconstruct its own input.

1.2. Types

Autoencoders come in several variations, each with unique constraints and use cases:

• Undercomplete Autoencoders: The simplest form, where the bottleneck layer is smaller than the input, forcing the network to learn the most salient features for dimensionality reduction.
• Regularized Autoencoders: A broader class that uses regularization techniques to prevent overfitting and learn more robust features. This includes the types below.
• Sparse Autoencoders (SAEs): Constrains the number of neurons that can be active at one time. This allows the network to have a large capacity while forcing it to learn specific features with different nodes.
• Denoising Autoencoders: Trained to reconstruct a clean, original input from a partially corrupted version. This forces the model to learn robust features and ignore noise.
• Contractive Autoencoders: Designed to be insensitive to small variations in the input data, encouraging the model to learn features that capture the underlying structure rather than minor details.
• Variational Autoencoders (VAEs): Learns the parameters of a probability distribution representing the data. This makes it a generative model, capable of creating new data samples by sampling from this distribution.

1.3. Structures

The structure of an autoencoder is composed of two main parts: the Encoder and the Decoder.

Encoder

The Encoder's job is to compress the input data. It takes the high-dimensional input (like an image) and passes it through a series of layers that progressively reduce the dimensions. The final output is a compact, low-dimensional representation, often called the bottleneck or latent representation.

Decoder

The Decoder's job is to reconstruct the original data from the compressed representation. It takes the low-dimensional output from the encoder and passes it through a series of layers that progressively increase the dimensions, aiming to recreate the input as accurately as possible.

Comparison: Encoder vs. Decoder

2. Application

Autoencoders are well-suited for tasks that benefit from learning the underlying structure of data in an unsupervised manner.

2.1. Dimensionality Reduction

By learning a compressed representation, autoencoders can be used to reduce the number of features in a dataset. This is useful for data visualization and can improve the performance of other models.

2.2. Image and Audio Denoising

An autoencoder can be trained on clean data and then used to clean up noisy inputs. It reconstructs a clean version from a corrupted input, effectively filtering out the noise.

2.3. Generative Tasks

Variational Autoencoders (VAEs) can generate new data. By sampling points from the learned latent space, the decoder can create new, plausible data samples that resemble the original training data.

2.4. Anomaly Detection and Facial Recognition

Autoencoders are excellent for detecting outliers. Trained only on "normal" data, they produce a high reconstruction error for anomalous inputs, signaling a deviation. This can be used for fraud detection or confirming a genuine match.

1. 개요

1.1. 정의

오토인코더(Autoencoder)

• 데이터를 저차원 표현으로 압축(인코딩)하고
• 다시 원본 형태로 복원(디코딩)하도록 학습하는 비지도 학습 신경망.
• 스스로 자기 자신의 입력을 재구성하고 압축된 잠재 공간에 데이터의 가장 본질적인(essential) 특징을 학습하는 것을 주요 목표로 함.

1.2. 종류

데이터 조건과 환경 등에 맞추어 여러 버전의 오토인코더가 있음.

• 과소완전 오토인코더 (Undercomplete Autoencoders): 가장 단순한 형태. 병목 계층이 입력보다 작아 네트워크가 차원 축소를 위해 가장 두드러진 특징을 학습하도록 강제함.
• 정규화 오토인코더 (Regularized Autoencoders): 과적합을 방지하고 더 강한 특징을 학습하기 위해 정규화 기법을 사용. 더 넓은 범위이며 아래 오토인코더들 포함
• 희소 오토인코더 (Sparse Autoencoders): 한 번에 활성화될 수 있는 뉴런의 수를 제한. => 네트워크가 큰 용량을 가지면서도 다른 노드로 특정 특징을 학습하도록 강제함.
• 잡음 제거 오토인코더 (Denoising Autoencoders): 부분적으로 손상된 입력으로부터 깨끗한 원본 입력을 재구성하도록 학습됨. 이는 모델이 강건한(robust) 특징을 배우고 노이즈를 무시하도록 강제함.
• 축소 오토인코더 (Contractive Autoencoders): 입력 데이터의 작은 변화에 둔감하도록 설계 => 모델이 사소한 디테일보다 근본적인 구조를 포착하는 특징을 학습하도록 함.
• 변이형 오토인코더 (Variational Autoencoders): 데이터를 나타내는 확률 분포의 매개변수를 학습 => 잠재 공간 분포에서 샘플링하여 (새로운 데이터를 생성할 수 있는) 생성 모델이 됨.

1.3. 구조

오토인코더의 구조는 인코더와 디코더, 두 가지 주요 부분으로 구성됨.

인코더 (Encoder)

입력 데이터를 압축하는 역할. 고차원 입력을 받아 점진적으로 차원을 축소하는 신경망 층을 통과시킴. 최종 출력은 데이터의 압축된 저차원 표현이며, 병목(bottleneck) 또는 잠재 표현(latent representation) 이라 말함.

디코더 (Decoder)

압축된 표현으로부터 원본 데이터를 복원하는 역할. 인코더의 저차원 출력을 받아 점진적으로 차원을 확대하는 신경망 층을 통과시켜, 가능한 한 원본 입력과 가깝게 재구성하는 것을 목표로 함.

비교: 인코더 vs. 디코더

2. 적용 분야

오토인코더는 비지도 방식으로 데이터의 근본적인 구조를 학습하는 것이 유용한 작업에 매우 적합함.

2.1. 차원 축소

데이터의 압축된 표현을 학습하여 데이터셋의 특징 수를 줄이는 데 사용. 데이터 시각화에 유용하며 다른 모델의 성능을 향상시킬 수 있음.

2.2. 이미지 및 오디오 노이즈 제거

깨끗한 데이터로 학습시킨 후 노이즈가 낀 입력을 정리하는 데 사용. 손상된 입력으로부터 깨끗한 버전을 재구성하여 효과적으로 노이즈를 필터링함.

2.3. 생성

변이형 오토인코더(VAE)는 새로운 데이터를 생성할 수 있음. 학습된 잠재 공간에서 포인트를 샘플링하여, 디코더가 원본 학습 데이터와 유사한 새로운 데이터를 만들어 냄.

2.4. 이상 탐지 및 얼굴 인식

이상치를 탐지하는 데 탁월함. "정상" 데이터로만 학습되어 비정상적 입력에 대해 높은 재구성 오류를 생성하며, 이는 편차를 나타내는 신호가 됨. 사기 탐지나 진위 여부 확인에 사용될 수 있음.

Reference Image https://www.ibm.com/think/topics/autoencoder https://en.wikipedia.org/wiki/Autoencoder https://www.v7labs.com/blog/autoencoders-guide

1. Input Layer

• Role: Accepts the raw pixel values of an image, typically represented as a matrix of (height x width x color channels).

2. Convolutional layers

• Role: These are the core building blocks of a CNN. They use 'kernels' (or filters) to convolve the input, extracting key features like edges, corners, and textures. The result is then passed to the next layer.
• Benefit: They can extract essential features while preserving the spatial relationships between pixels.s

3. Activation Function

• Role: Introduces non-linearity to the model. This allows the network to learn more complex patterns, which improves calculation effectiveness and accuracy.

4. Pooling layers

• Role: Reduce the spatial dimensions (width and height) of the feature maps while retaining the most important information.
• Benefit: This decreases the computational load, helps mitigate overfitting, and improves the model's generalization ability.
• Types:

    - Max Pooling: Selects the maximum value from each patch of the feature map.
    - Average Pooling: Calculates the average value from each patch of the feature map.

5. Fully Connected Layers

• Role: Connects every neuron from the previous layer to every neuron in the current layer. This layer takes the high-level features extracted by the previous layers and uses them to make the final classification decisions.

6. Output Layer

• Role: Generates the final output of the network, such as a probability distribution for classification tasks, based on the features learned throughout the network.

1. 입력층 (Input Layer)

• 역할: 이미지의 원본 픽셀 값(색상 채널 x 높이 x 너비 x 깊이 )을 받는 곳

2. 합성곱층 (Convolutional Layers)

• 역할: CNN의 핵심 구성 요소. '커널' 또는 '필터'를 사용 -> 입력 데이터에 대한 합성곱 연산 -> 특징(feature) 추출 및 결과를 다음 계층으로 전달.

• 장점: 이미지의 공간적 구조를 유지하면서 핵심 특징을 효과적으로 추출 가능

3. 활성화 함수 (Activation Function)

• 역할: 모델에 비선형성(non-linearity) 추가 -> 계산 효율성과 정확도 높임. 이를 통해 더 복잡한 패턴을 학습 가능.

4. 풀링층 (Pooling Layers)

• 역할: 특징 맵(feature map)의 필수 정보는 유지 + 차원(주로 가로, 세로)을 축소

• 장점: 계산량 줄이기 & 과적합(overfitting) 방지 & 모델 일반화 성능 향상

• 종류:

  • 최대 풀링 (Max Pooling): 특정 영역에서 가장 큰 값을 선택
  • 평균 풀링 (Average Pooling): 특정 영역 값들의 평균을 계산하여 선택

5. 완전 연결 계층 (Fully Connected Layers)

• 역할: 이전 계층의 모든 뉴런을 다음 계층의 모든 뉴런에 연결하여 최종적인 결정을 내림

6. 출력층 (Output Layer)

• 역할: 학습된 특징들을 바탕으로 최종 예측 값이나 분류 결과를 생성

Reference 참고 Image Reference 이미지 출처 https://www.ibm.com/think/topics/convolutional-neural-networks https://blog.lukmaanias.com/2024/12/18/convolutional-neural-networks-cnn-an-in-depth-exploration/

* The following content is written in English, then in Korean.
* 아래 글은 영어 -> 한국어 순으로 작성되어 있습니다.

1. Definition

1.1 PyTorch Tensor

• import torch; torch.tensor()
• The fundamental data structure in PyTorch.
• An n-dimensional array optimized for deep learning operations.
• Primary Use: Building and training deep learning models.

1.2 NumPy Array

• import numpy as np; np.array()
• The fundamental data structure for numerical computing in Python.
• An n-dimensional array for general-purpose scientific computation.
• Primary Use: Scientific computing (data analysis, linear algebra, etc.).

2. Comparison

2.1 Common Points

• Represent n-dimensional numerical data.
• Homogeneous (store elements of a single data type).
• Easily converted between each other (.numpy(), torch.from_numpy()).

2.2 Differences

• Hardware Acceleration (GPU Usage):
  • Tensor: Optimized for GPU operations (accelerates deep learning).
    • Array: Limited to CPU operations.
• Automatic Differentiation:
  • Tensor: Built-in autograd engine (essential for training neural networks).
  • Array: No built-in autograd functionality.
• Ecosystem Integration:
  • Tensor: Integrated with the PyTorch ecosystem (e.g., torch.nn, optimizers).
  • Array: Integrated with the scientific computing ecosystem (e.g., Scikit-learn, Pandas).

3. Conclusion

Use PyTorch Tensors for deep learning models and GPU-accelerated tasks; use NumPy Arrays for general-purpose scientific computing and data analysis.

1. 정의

1.1 PyTorch Tensor

• import torch; torch.tensor()
• 파이토치의 기본 데이터 구조.
• 딥러닝 연산에 최적화된 N차원 배열.
• 주로 딥러닝 모델 구축 및 훈련에 사용

1.2 NumPy Array

• import numpy as np; np.array()
• 파이썬 수치 연산의 기본 데이터 구조.
• 범용 과학 계산을 위한 N차원 배열.
• 주로 계산 과학(scientific computic - 데이터 분석, 선형대수 등)에 사용

2. 비교

2.1 공통점

• N차원 수치 데이터 표현.
• 동일한 데이터 타입만 저장 (Homogeneous).
• 상호 변환 용이 (.numpy(), torch.from_numpy()).

2.2 차이점

• 하드웨어 가속 (GPU 사용 여부):
  • Tensor: CPU 연산도 가능하지만 GPU 연산도 가능(GPU 연산에 최적화 -> 딥러닝 가속).
  • Array: CPU 연산에 제한됨.
• 자동 미분:
  • Tensor: 자동 미분 기능(autograd) 내장 (신경망 학습에 필수).
  • Array: 자동 미분 기능 없음.
• 생태계:
  • Tensor: PyTorch 생태계와 연결 (torch.nn, 옵티마이저 등).
  • Array: Scientific 생태계와 연결 (Scikit-learn, Pandas 등).

3. 결론

• 딥러닝 모델과 GPU 가속 작업 -> PyTorch Tensor
• 일반적인 Sceintific computing 및 데이터 분석 -> NumPy Array를 사용

Reference Link 참고 링크 https://www.kaggle.com/code/amirmotefaker/pytorch-vs-numpy https://www.geeksforgeeks.org/deep-learning/pytorch-tensor-vs-numpy-array/

* The following content is written in English, then in Korean.
* 아래 글은 영어 -> 한국어 순으로 작성되어 있습니다.

1. Basic Information

1.1 PyTorch

• Developed by: Meta (formerly Facebook)
• Keywords: Pythonic, Dynamic Graph (Define-by-Run), Intuitive, Flexible
• Usage: Strong in research, experimentation, and education.

1.2 TensorFlow

• Developed by: Google
• Keywords: End-to-end Platform, Static Graph (Define-and-Run), Deployment & Scalability
• Usage: Strong in large-scale production and real-world services.

2. Comparison

2.1 Common Points

• Basic Unit: Tensor
• Purpose: Open-source frameworks for ML/DL.
• Modern Trend: Both are evolving to support features from the other, closing the gap between them.

2.2 Differences

• Computational Graph & Debugging:

  • PyTorch: Uses a Dynamic Graph (Define-by-Run). This allows for more intuitive, Python-style coding and makes debugging significantly easier.
  • TensorFlow: Uses a Static Graph (Define-and-Run), which is optimized for performance and deployment.(Since TF 2.x, Eager Execution has been the default, enabling intuitive coding similar to PyTorch)

• Ecosystem & Deployment:

  • PyTorch: Strong presence in the research community, with an ecosystem for production that is expanding rapidly.
  • TensorFlow: Holds an advantage in production, possessing a mature and comprehensive suite of deployment tools (TensorFlow Serving, TFX, TF Lite).

3. Conclusion: Which one is better?

There is no absolute winner; the choice depends on the project's primary goal.

• For Research & Flexibility → PyTorch is often preferred for its intuitive coding and easy debugging.
• For Production & Scalability → TensorFlow is often chosen for its mature deployment tools and ecosystem.

As an AI engineer, understanding the core concepts of both is a major advantage :>

1. 기본 정보

1.1 PyTorch (파이토치)

• 개발사: Meta (구 페이스북)
• 키워드: Pythonic(파이썬다운), 동적 그래프 (Define-by-Run), 직관적, 유연함
• 주요 용도: 연구, 실험, 교육 분야에서 강세

1.2 TensorFlow (텐서플로우)

• 개발사: Google (구글)
• 키워드: End-to-End 플랫폼, 정적 그래프 (Define-and-Run), 배포 및 확장성
• 주요 용도: 대규모 상용 서비스 및 실제 프로덕션 환경에서 강세

2. 비교

2.1 공통점

• 기본 단위: 텐서(Tensor)
• 목적: 오픈소스 머신러닝/딥러닝 프레임워크
• 최신 경향: 서로의 장점을 흡수하며 두 프레임워크 간의 격차가 줄어드는 추세

2.2 차이점

• 계산 그래프와 디버깅:

  • PyTorch: 동적 그래프 (Define-by-Run) 방식. 코드가 직관적이고 파이썬 문법과 유사해 디버깅이 매우 쉬움.
  • TensorFlow: 정적 그래프 (Define-and-Run) 방식. 성능 및 배포에 최적화.(TF 2.x부터 즉시 실행하는 것이 기본이 되어 PyTorch처럼 직관적인 코딩이 가능하게 됨..!)

• 생태계와 배포:

  • PyTorch: 연구 커뮤니티 중심으로 강하며, 프로덕션을 위한 생태계가 빠르게 확장되고 있음.
  • TensorFlow: 프로덕션(상용화) 환경에서 강점을 가지며, 성숙하고 종합적인 배포 도구(TensorFlow Serving, TFX, TF Lite 등)를 보유함.

3. 결론: 그래서 어떤 것을 선택해야 하는가?

절대적인 승자는 없다! 프로젝트 핵심 목표에 따라 선택은 달라진다.

• 연구 및 유연성 → PyTorch: 직관적인 코드와 쉬운 디버깅으로 선호됨.
• 프로덕션 및 확장성 → TensorFlow: 성숙한 배포 도구와 생태계로 선호됨.

결론적으로 AI 엔지니어가 되려면 두 프레임워크의 핵심 개념을 모두 이해하고 다룰 줄 아는 것이 중요합니다 :>

• Insitnct: Simply check every possible pair of numeber in the list. I used two nested for loops to accomplish this.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        ans = []

        for i, num1 in enumerate(nums):
            for j, num2 in enumerate(nums):
                if i < j and num1 + num2 == target:
                    ans.append(i)
                    ans.append(j)

        return ans

Problem: The two nested loops result in a time complexity of O(n^2). This is because for every element, the inner loop has to scan the entire list again, making it very slow for large inputs.

Second try

• Instinct: My next thought was to avoid the inner loop. For each number, I could calculate its complement (target - num) and then use Python's in and .index() to check if it exists in the list.

  class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        ans = []
  
        for i, num in enumerate(nums):
            if ((target - num) in nums) and (nums.index(target-num) > i) :
                ans.append(i)
                ans.append(nums.index(target-num))
  
        return ans
  

Problem: `.index(value)` always find the *first* occurrence of `value` in the list & still doesn't solve time complexity problem

### Third try
- Instinct:  Instead of a list, I used a `dictionary` to store the numbers I'd already seen.

> Q. Why `dictionary` is better than `list` in terms of `time complexity?`

> A. There is difference between `dictionary` and `list` about *how they store and retrieve data.* 
- `dictionary` : Use a 'direct lookup' system using a key (Hashing, O(1)) (e.g. using a book's index to find a topic in a book)
- `list`: Use a 'search every item' system(Linear scan, O(n)) (e.g. reading a book page-by-page to do same thing)

class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: for i, num in enumerate(nums): if num not in seen_numbers.keys(): seen_numbers[target-num] = i elif num in seen_numbers.keys(): result.append(seen_numbers[num]) result.append(i)

    return result

Finally it passed!


Problem: But it doesn't look clean and practical, and I finally realized I missed hint by reading the problem's description carefully:
> You may assume that each input would have exactly one solution,


### Fourth try
- Instinct: I can return immediately after finding the *first* valid pair, which simplifies the logic.

class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: seen_numbers = {}

    for i, num in enumerate(nums):
        if num in seen_numbers:
            return [seen_numbers[num], i]
        else:
            new_element = target - num
            seen_numbers[new_element] = i

![](https://velog.velcdn.com/images/sujikim-hattoo/post/24551b06-409d-457f-87f8-8305af205531/image.png)


---
### **Conclusion:** 
This process taught me that I was initially a bit confused about the practical application of a `dictionary` and the importance of edge cases. It's crucial to consider edge cases, but first of all, it's essential to *focus on the problem's definition and constraints.*