1. MAE (Masked Autoencoder)는 ViT(Vision Transformer) 사전학습에 효과적임.

2. MAE는 부분적으로 마스킹된 이미지를 입력으로 받아 전체 이미지를 복원 → 문맥 집약 능력(context aggregation ability)이 생김. 의료 영상은 해부학적 구조들이 긴밀히 연결되어 있어 문맥 집약 능력이 특히 중요.

3. ImageNet 규모의 의료 영상 데이터셋 부재 → 제안: Self Pre-training (목표 데이터셋(target dataset)의 학습용 데이터 위에서 ViT를 사전 학습).

결과: Self Pre-training으로 X-ray 분류, CT 다장기 분할, MRI 뇌종양 분할 모두 성능 향상.

MAE (Masked Autoencoder)

1. 입력 이미지 (Input) 원본 이미지를 작은 패치(patch)로 나눕니다. 이 패치 중 일부는 마스킹 처리됩니다.

2. 인코더 (Encoder) 마스킹되지 않은 패치들만 Transformer 기반 인코더에 입력. 인코더는 이 패치들을 잠재 표현(latent representation)으로 변환합니다.

3. 디코더 (Decoder) 디코더는 전체 패치(마스킹된 부분 포함)를 입력받아 원래 이미지를 복원하려고 시도.

4. 출력 (Target) 디코더가 복원한 이미지를 원본 이미지와 비교하여 복원 손실(reconstruction loss)을 계산. 이 과정을 통해 모델은 이미지의 전역적 문맥을 학습합니다.

ViT(Vision Transformer)

• 이미지 처리에 Transformer 구조를 적용한 모델

1. ViT는 사전학습이 중요하다

• ViT는 CNN과 달리 로컬 패턴(예: 엣지, 텍스처)을 자연스럽게 학습하지 못함.
• 따라서 대규모 데이터에서 사전학습(pretraining)을 해야 좋은 성능을 냅니다.
• 사전학습 후, 다운스트림 작업(분류, 탐지 등)에 파인튜닝(finetuning)을 합니다.

2. MAE는 ViT 사전학습에 적합한 이유

• MAE는 ViT 구조를 그대로 사용합니다. (패치 분할 → Transformer 인코더)
• 학습 목표는 마스킹된 이미지 복원 → 이미지의 전역적(global) 문맥을 이해해야 함.
• 이 과정에서 ViT는 풍부한 시각적 표현을 학습하게 됩니다. 라벨이 필요 없으므로 대규모 비라벨 데이터로 학습 가능 → 강력한 사전학습 효과.

3. 효과

• MAE로 사전학습한 ViT는 ImageNet 분류, 객체 탐지, 세그멘테이션 등에서 성능이 크게 향상.
• 특히 라벨이 부족한 상황에서 매우 유리.

2. INTRODUCTION

분할(segmentation)의 경우, 목표 대상의 고유한 특징뿐 아니라 주변 조직의 특징 역시 특정 구조를 구분하는 데 도움이 된다.

예를 들어, 뇌종양이 존재하면 주변 미세환경에서도 부종, 뇌 조직의 구조적 변화, 혈관화 증가 등의 추가적인 변화가 발생한다.

이 논문에서는 문맥 정보 학습에 대한 엄격한 요구 조건을 부여하는 것이 딥러닝 기반 의료 영상 분석의 성능을 향상시킬 수 있다고 가정

MAE Self Pre-training

1. 입력 이미지 분할

• CT/MRI 이미지를 여러 개의 작은 패치로 나눔.
• 일부 패치는 mask 처리(회색 블록) 되어 encoder에는 입력되지 않음.

2. ViT Encoder

• 보이는 패치만 입력으로 받아 전체 문맥(Context)을 학습.
• Encoder는 이미지의 전반적인 구조적 관계를 이해하는 표현(representation)을 학습.

3. Transformer Decoder

• Encoder 출력 + mask token을 받아 마스킹된 영역을 복원(reconstruction).
• 이 과정에서 Encoder가 “부분만 보고 전체를 이해하는 능력”을 얻게 됨.

UNETR Segmentation 단계

1. 사전학습된 ViT Encoder 활용

• 앞서 MAE로 학습한 Encoder weight를 segmentation 모델의 backbone으로 가져옴.
• 즉, Encoder는 이미 “의료 영상의 문맥적 특징”을 잘 파악할 수 있는 상태임.

2. UNETR Decoder 연결

• ViT Encoder의 여러 단계 출력(z3, z6, z9, z12)을 U-Net처럼 skip connection 구조에 연결.
• Decoder가 이를 이용해 segmentation 맵을 생성.

3. Fine-tuning

• 전체 네트워크(Encoder + Decoder)를 segmentation 데이터셋에서 파인튜닝.
• 이렇게 하면 초기부터 좋은 표현으로 시작하기 때문에 학습 효율과 성능이 개선됨.

요약: 이 그림은 1단계(마스크 복원 Self Pre-training) → 2단계(Segmentation Fine-tuning)의 전체 파이프라인을 보여줍니다.

• Pre-training: MAE로 “문맥 기반 표현” 학습.
• Downstream task: 해당 Encoder를 가져와 segmentation 또는 classification 수행.

정리

• 의료 영상 분석은 주변 구조와의 관계까지 고려해야 정확도 향상 가능. 예: 흉부 X-ray에서 폐 질환 분류 시 심장·종격동의 변화도 참고 필요.

• 종양 분할 시 주변 부종, 구조 변형, 혈관화 증가 등이 단서가 됨.

• 최근 Self-Supervised Learning (SSL) 발전 → Masked Image Modeling (MIM) 전략이 ViT 학습에 효과적임. MAE는 단순하면서도 효과적인 MIM 방법.

• 본 연구 목표 MAE 기반 self pre-training 패러다임을 의료 영상 분석에 제안 -> MAE 사전학습을 다운스트림 과제와 동일한 데이터셋의 학습(train) 세트에서 수행 = Self pre-training Self pre-training은 적절한 사전학습용 데이터를 구하기 어려운 다양한 상황에서 유용할 수 있으며, 사전학습과 파인튜닝 간의 데이터 불일치(domain discrepancy) 문제를 피할 수 있다.

세 과제에 적용

1. 흉부 X-ray 질환 분류 (CXR14 데이터셋)
2. CT 다장기 분할 (BTCV 데이터셋)
3. MRI 뇌종양 분할 (BraTS, Medical Segmentation Decathlon)

결과

1. MAE self pre-training이 무작위 초기화(random initialization)보다 의료 영상 분류와 분할 성능을 크게 향상
2. 모든 데이터셋에서 ImageNet 기반 사전학습보다 더 뛰어난 성능을 달성

   3. METHODOLOGY

Vision Transformer (ViT)

입력 이미지를 패치 단위로 나누어 sequence로 변환.

포지션 임베딩 추가.

Transformer block(Attention + MLP)으로 학습.

사전학습 시엔 sine-cosine positional embedding 사용.

MAE Self Pre-training

입력 이미지를 랜덤하게 마스킹 (일부 패치만 encoder 입력).

Encoder: 보이는 패치만으로 representation 학습.

Decoder: mask token + encoder feature로 마스킹된 영역 복원.

Loss: MSE, 단 마스크된 영역만 복원.

Downstream Tasks

Classification: ViT + Linear Classifier (multi-label → BCE loss).

Segmentation: UNETR(Transformer 기반 U-Net 구조) decoder 추가.

사전학습된 encoder weight로 초기화 후 fine-tuning.

2.1 Preliminary: Vision Transformer (ViT)

Backbone으로 ViT 사용 (pre-training, downstream 공통).

구성 요소:

1. Patch Embedding: 3D 볼륨 이미지를 작은 패치 단위로 나눠 시퀀스로 변환. 입력: 𝑥∈𝑅𝐻×𝑊×𝐷×𝐶x∈R H×W×D×C 출력: Flatten된 패치 시퀀스 → 선형 프로젝션으로 임베딩.

2. Position Embedding: 위치 정보를 유지하기 위해 임베딩 추가. 일반적으로 learnable 1D embedding 사용. 그러나 실험적으로 학습 가능한 1D embedding은 MAE 복원에 방해 → 대신 sine-cosine embedding 사용. 다운스트림 작업에서는 sine-cosine으로 초기화 후 학습.

3. Transformer Block: Multi-Head Self-Attention(MSA)와 MLP 블록 반복.

2.2 Self Pre-training with Masked Autoencoders (MAE)

Encoder (ViT): 입력 이미지를 패치로 분할 → 일부는 마스킹, 일부만 encoder 입력.

Encoder는 보이는 패치들로부터 전체 문맥적 표현을 학습.

Decoder (Transformer): Encoder 출력 + mask token 입력 → 원래 마스크된 영역 복원.

Decoder는 사전학습에만 사용, downstream에서는 제거됨.

Loss Function:

Reconstruction loss (MSE).

전체 이미지를 복원하는 게 아니라 mask된 영역만 예측 → 성능 더 좋음.

Normalized pixel/voxel 값이 raw 값보다 더 나은 학습 목표.

구성

첫 번째 줄 (First row): 원본 이미지 (Original image).

Chest X-ray, Abdominal CT, Brain MRI (왼쪽 → 오른쪽).

두 번째 줄 (Second row): 마스킹된 이미지 (Masked image).

이미지 일부 패치가 회색/검은색으로 가려져 있음.

Encoder는 이 보이는 일부 패치만 입력으로 받아 학습.

세 번째 줄 (Third row): 복원된 이미지 (Reconstructed image).

Encoder+Decoder가 마스킹된 영역을 추론해 채운 결과.

실제 원본과는 약간 다르지만, 전체적인 구조는 잘 복원됨.

의미

MAE는 이미지의 75% 이상을 가려도 나머지 정보로 전체를 추론할 수 있다는 걸 보여줌.

복원 품질이 완벽하진 않지만, 중요한 건 Decoder 품질이 아니라 Encoder가 문맥적 표현을 학습하는 것.

의료 영상에서 문맥 이해가 중요한 이유:

X-ray → 폐 질환은 주변 심장/종격동 구조까지 보고 추론 가능.

CT → 장기의 위치 관계, 형태적 연속성을 학습.

MRI → 종양뿐만 아니라 주변 뇌 조직의 변화를 함께 파악.

✅ 요약: 이 그림은 MAE가 일부 패치만 보고 전체 이미지를 재구성하는 과정을 시각적으로 보여주며, 이를 통해 Encoder가 풍부한 문맥 표현(contextual representation)을 학습함을 증명합니다.

2.3 Architectures for Downstream Tasks

Classification:

ViT encoder + Linear classifier head.

Chest X-ray는 multi-label 분류이므로 BCE loss 사용.

Segmentation (UNETR 기반):

MAE 사전학습된 ViT encoder + 랜덤 초기화된 UNETR decoder.

구조: U-Net처럼 encoder의 여러 resolution feature를 decoder에 skip-connection.

Encoder representation을 reshape → spatial dimension 복원 → upsampling & concat으로 세부 segmentation 맵 생성.

📌 요약 정리:

ViT를 backbone으로 쓰되, MAE를 통해 mask 복원 pre-training → 문맥 이해 능력 강화.

Pre-training: Encoder+Decoder(MAE), Loss는 MSE(masked 부분만).

Downstream: Encoder weight를 가져와서 분류(Linear) 또는 분할(UNETR) head 연결.

4. EXPERIMENTS AND RESULTS

1️⃣ BTCV (Abdomen CT, 첫 두 줄)

첫 번째 줄:

UNETR에서는 잘못된 false positive segmentation(주황색 화살표)이 존재.

MAE pre-training을 거친 UNETR은 이 오류가 사라짐 → 더 정확한 장기 분할.

두 번째 줄:

UNETR은 위(stomach) 영역 분할이 불완전 (빨간 별표).

UNETR+MAE는 훨씬 더 완전하게 위를 분할.

👉 결론: MAE pre-training 덕분에 오탐 감소, 장기 분할 정확도 향상.

2️⃣ BraTS (Brain Tumor MRI, 마지막 두 줄)

세 번째 줄:

UNETR은 종양 주변(peripheral) 세부적인 종양 핵(yellow necrotic core, 흰색 화살표)을 놓침.

UNETR+MAE는 이 작은 부분까지 포착 → 더 정밀한 segmentation.

네 번째 줄:

UNETR은 괴사 핵(necrotic core) 분할이 거의 없음.

UNETR+MAE는 해당 영역을 더 잘 탐지.

👉 결론: MAE pre-training은 종양 내부 구조(코어, 주변부)까지 더 정확히 분할.

✅ 요약

BTCV (CT 다장기 분할):

False positive 감소.

위(stomach) 같은 작은 장기 분할 성능 향상.

BraTS (MRI 뇌종양 분할):

종양 내부 구조(괴사 코어, 주변부)까지 더 잘 포착.

기존 UNETR보다 더 세밀하고 안정적인 분할 성능.

즉, MAE self pre-training → 단순 수치 향상뿐 아니라, 실제 시각적 분할 품질도 개선됨을 보여주는 그림입니다.

왼쪽 블록 (Method 비교)

UNETR (기본 모델)

UNETR + ImageNet Pre-training

UNETR + MAE Self Pre-training

👉 세 가지 방법의 뇌종양 분할 성능 비교 (DSC↑ = Dice Score, HD95↓ = Hausdorff Distance 95).

오른쪽 블록 (Ablation Study)

Mask ratio (마스크 비율) & Pre-training Epochs 변화에 따른 평균 DSC 결과.

Mask ratio = 입력 이미지에서 가리는 비율.

📊 주요 결과 1️⃣ Method 비교 (왼쪽)

UNETR 기본: Avg DSC = 77.40, HD95 = 7.78

UNETR + ImageNet: 약간 향상 → Avg DSC = 77.78, HD95 = 7.38

UNETR + MAE: 가장 높음 → Avg DSC = 78.91, HD95 = 7.22

👉 결론: MAE self pre-training이 ImageNet 기반 pre-training보다 효과적.

2️⃣ 세부 클래스별 (WT, ET, TC)

WT (Whole Tumor): MAE = 90.84 (최고)

ET (Enhancing Tumor): MAE = 63.88 (최고)

TC (Tumor Core): MAE = 82.00 (최고)

👉 모든 세부 종양 영역에서 MAE가 우세.

3️⃣ Ablation Study (오른쪽)

Mask Ratio 효과:

87.5% → Avg DSC 77.14 (낮음)

75% → Avg DSC 78.14 ~ 78.43 (보통)

50% → Avg DSC 78.42 (500 epoch), 83.2 (10k epoch)

25% → Avg DSC 78.71 (500 epoch), 83.18 (10k epoch)

12.5% → Avg DSC 78.91 (500 epoch), 83.52 (10k epoch, 최고 성능)

👉 의료 영상에서는 낮은 mask ratio (12.5%~25%)가 최적, 자연 이미지처럼 75% 이상 마스킹은 오히려 성능 저하.

Epoch 효과:

Pre-training을 오래 할수록 성능이 향상되지만, 40k epoch에서는 오히려 성능 하락 (과적합) 발생.

✅ 요약

MAE self pre-training > ImageNet pre-training > Random init

모든 종양 영역(Whole, Enhancing, Core)에서 MAE가 최고 성능 달성

낮은 mask ratio (12.5%25%) + 충분한 pre-training epoch (10k) 조합이 최적.

너무 많은 epoch (40k)는 오히려 성능 저하 (overfitting).

Datasets

ChestX-ray14: 112,120장의 X-ray (multi-class 분류).

BTCV: 30명 환자의 복부 CT, 13개 장기 annotation (8개 장기 평가).

BraTS (MSD): 484명의 멀티모달 MRI, 종양 분할.

Implementation

Backbone: ViT-B/16

Optimizer: AdamW

Pre-training epoch: CXR14 (800), BTCV (10k), BraTS (500)

Augmentation: crop, flip, normalize

Results

ChestX-ray 분류

ViT scratch: mAUC 74.4%

ImageNet pretrained: 80.7%

MAE self pre-training: 81.5%

BTCV 다장기 CT 분할

UNETR baseline: DSC 78.8%

ImageNet pretrained: 79.7%

MAE self pre-training: 83.5% (큰 향상)

BraTS 뇌종양 MRI 분할

UNETR baseline: DSC 77.4%

ImageNet pretrained: 77.8%

MAE self pre-training: 78.9%

Ablation Study

마스크 비율: 자연 영상(MAE 논문)에서는 75% 이상이 최적이지만, 의료 영상에서는 낮은 비율(12.5%)이 더 성능 좋음.

Pre-training epoch: 적당히 길수록 좋지만 너무 길면 과적합.

3.1 Datasets and Implementation Details

ChestX-ray14 (CXR14):

11만 개 이상의 흉부 X-ray (32,717 환자).

Train/val 80%, test 20%.

Metric: multi-class AUC.

BTCV (Abdomen CT, 다장기 분할):

30명 CT, 13개 장기 라벨링.

18개 학습, 12개 검증.

Metric: 평균 Dice Similarity Coefficient (DSC), 95% Hausdorff Distance (HD).

BraTS (MSD Brain Tumor Segmentation):

484개 multi-modal MRI (FLAIR, T1w, T1-Gd, T2w).

라벨: edema, enhancing tumor, necrotic/non-enhancing core.

Metric: DSC, 95% HD.

Train 80%, Validation 20%.

Implementation:

PyTorch + MONAI.

Backbone: ViT-B/16.

Optimizer: AdamW.

Patch size: 16×16 (2D), 16×16×16 (3D).

Data Preprocessing:

CXR14: 히스토그램 균등화, 랜덤 crop (224×224).

BTCV: intensity clipping, normalization, 랜덤 crop (96³).

BraTS: instance-wise normalization, 랜덤 crop (128³).

MAE Pre-training:

LR=1.5e-4, weight decay=0.05, cosine schedule.

Epochs: 800 (CXR), 10k (BTCV), 500 (BraTS).

Batch size: 256 (CXR), 6 (BTCV, BraTS).

Fine-tuning:

Layer-wise LR decay=0.75, DropPath=0.1.

LR: 1e-3 (CXR), 8e-4 (BTCV), 4e-4 (BraTS).

Batch size: 동일 (256, 6, 6).

3.2 Results

(1) MAE Reconstruction

Fig. 2: 마스크 비율 75%.

결과: 원본 → 마스크 → 복원 순서.

복원된 visible patch는 다소 blur하지만, masked 영역은 잘 복원.

목표는 reconstruction 품질 자체가 아니라 문맥적 표현 학습.

(2) Abdomen Multi-organ Segmentation (BTCV)

Baseline UNETR: 78.8% DSC.

UNETR+ImageNet: 79.7%.

UNETR+MAE: 83.5% (큰 향상).

적은 데이터(N=30)에서도 효과적 → 소규모 의료 데이터에서 MAE의 잠재력 입증.

목표는 SOTA가 아니라 MAE self pre-training의 효과성 증명.

(3) Brain Tumor Segmentation (BraTS, MSD)

Baseline UNETR: 77.4% DSC / 7.78mm HD95.

UNETR+ImageNet: 77.8% / 7.38mm.

UNETR+MAE (mask=12.5%) → 78.9% / 7.22mm.

개선폭은 크진 않지만 안정적 성능 향상.

(4) Ablation Study (Mask Ratio & Epochs)

Pre-training Epochs: 길게 학습하면 성능이 좋아지지만, 너무 오래하면 오히려 과적합으로 성능 하락.

Mask Ratio: 자연 이미지에서는 높은 비율(75% 이상)이 효과적이지만,

의료 영상 segmentation은 낮은 mask 비율 (12.5% ~ 25%)이 가장 좋은 성능.

이유: 의료 영상은 구조적·문맥적 정보가 제한적이므로 지나치게 많이 가리면 복원이 어려움.

(5) Lung Disease Classification (CXR14)

ViT scratch (100 epoch): 74.4% mAUC.

ViT scratch (400 epoch): 74.9%.

ViT + ImageNet pretrain: 80.7%.

ViT + MAE self pretrain: 81.5%.

결과: ViT는 사전학습 없이 성능이 낮지만, MAE self pre-training은 ImageNet pre-training보다도 우수.

✅ 요약:

BTCV CT segmentation → 큰 성능 향상 (78.8% → 83.5%).

BraTS MRI segmentation → 소폭 향상 (77.4% → 78.9%).

ChestX-ray14 classification → ImageNet 사전학습보다도 우수 (80.7% → 81.5%).

Ablation: 의료 영상은 낮은 mask ratio가 효과적.

5. CONCLUSION

• MAE Self Pre-training은 의료 영상 분석에서 무작위 초기화, ImageNet 사전학습 모두를 능가하는 성능을 보임. 특히 ImageNet 사전학습보다 소규모 데이터셋 환경에서 효과적임을 입증.
• 2D (X-ray)뿐 아니라 3D (CT, MRI) 영상에도 적용 가능.
• 향후 예후 예측, 임상 결과 분석 같은 고차원적 의료 AI 작업으로 확장 가능.

권장 시간: 30분 권장 시간 복잡도: O(logN) 출제: 저자 출제

제약 조건

• decimal은 1,000만 이하의 양의 정수

풀이

1. 10진수 N을 2로 나눈 나머지를 저장하고 N은 2로 나눔
2. 몫이 0이 아니라면 나머지를 버리고 다시 1을 수행
3. 모든 과정이 끝나고 1에서 저장한 수를 뒤부터 순서대로 가져와 붙이기

def solution(decimal):
    stack = []
    while decimal > 0:
        remainder = decimal % 2
        stack.append(str(remainder))
        decimal //= 2
    binary = ""
    while stack:
        binary += stack.pop()

    return binary

시간 복잡도

• N은 이진수로 변환할 숫자
• N을 이진수로 변환하는 과정은 N이 1이 될 때까지 2로 게속 나누므로 연산횟수는 O(logN)
• 문자열의 +=연산자는 수행할 때마다 객체를 새로 생성. 따라서 시간 복잡도는 O((logN)^2)

소괄호 '(' , ')'로 구성된 문자열 s가 주어집니다. 이 때 괄호의 짝이 맞는지 판별하는 solution() 함수를 구현하세요. 열린 괄호는 자신과 가장 가까운 닫힌 괄호를 만나면 상쇄되며, 이때 반드시 열린 괄호가 닫힌 괄호보다 먼저 와야합니다. 이런 식으로 괄호를 없애는 과정을 반복했을 때, 남아있는 괄호가 없으면 짝이 맞다고 할 수 있습니다.

권장 시간: 30분 권장 시간 복잡도: O(N) 출제: 저자 출제

제약 조건

• s의 길이는 최대 10만이며, 빈 문자열인 경우는 없음
• 괄호의 짝이 맞으면 True, 짝이 맞지 않으면 False를 반환

풀이

닫힌 괄호가 임의 위치의 열린 괄호와 상쇄되는 것이 아니라 닫힌 괄호가 나오기 바로 전 즉, 가장 가까운 (최근) 열린 괄호와 상쇄 '최근' 이라는 키워드를 보고 스택을 떠올리는 감각을 키우자

1. 문자열을 앞에서 하나씩 보며 열린 괄호가 나오면 푸시
2. 닫힌 괄호가 나오면 팝 연산을 통해 최근 등장했던 열린 괄호 중 아직 상쇄하지 않은 열린 괄호를 확인하고 상쇄

def solution(s):
    stack = []
    for c in s:
        if c == "(":
            stack.append(c)
        elif c == ")":
            if not stack:
                return False
            else:
                stack.pop()

    if stack:
        return False
    else:
        return True

시간 복잡도

• N은 s의 길이
• s를 순회하며 괄호의 쌍을 확인하므로 시간 복잡도는 O(N)

https://school.programmers.co.kr/learn/courses/30/lessons/49994 게임 캐릭터를 4가지 명령어를 통해 움직이려 합니다. 명령어는 다음과 같습니다.

U: 위쪽으로 한 칸 가기 D: 아래쪽으로 한 칸 가기 R: 오른쪽으로 한 칸 가기 L: 왼쪽으로 한 칸 가기

캐릭터는 좌표평면의 (0, 0) 위치에서 시작합니다. 좌표평면의 경계는 왼쪽 위(-5, 5), 왼쪽 아래(-5, -5), 오른쪽 위(5, 5), 오른쪽 아래(5, -5)로 이루어져 있습니다.

예를 들어, "ULURRDLLU"로 명령했다면

1번 명령어부터 7번 명령어까지 다음과 같이 움직입니다.

8번 명령어부터 9번 명령어까지 다음과 같이 움직입니다.

이때, 우리는 게임 캐릭터가 지나간 길 중 캐릭터가 처음 걸어본 길의 길이를 구하려고 합니다. 예를 들어 위의 예시에서 게임 캐릭터가 움직인 길이는 9이지만, 캐릭터가 처음 걸어본 길의 길이는 7이 됩니다. (8, 9번 명령어에서 움직인 길은 2, 3번 명령어에서 이미 거쳐 간 길입니다)

단, 좌표평면의 경계를 넘어가는 명령어는 무시합니다.

예를 들어, "LULLLLLLU"로 명령했다면

1번 명령어부터 6번 명령어대로 움직인 후, 7, 8번 명령어는 무시합니다. 다시 9번 명령어대로 움직입니다.

이때 캐릭터가 처음 걸어본 길의 길이는 7이 됩니다.

명령어가 매개변수 dirs로 주어질 때, 게임 캐릭터가 처음 걸어본 길의 길이를 구하여 return 하는 solution 함수를 완성해 주세요.

권장 시간: 40분 권장 시간 복잡도: O(N) 출제: Summer/Winter Coding(~2018)

제약 조건

• dirs는 string형으로 주어지며, 'U', 'D', 'R', 'L' 이외에 문자는 주어지지 않음
• dirs의 길이는 500 이하의 자연수

풀이

주의

1. 중복 경로는 최종 길이에 포함하지 않음
2. 음수 좌표를 포함

문제의 핵심은 원점에서 출발해 최종 경로의 길이를 구하는 것이므로 원점을 변경해도 길이만 구할 수 있다면 상관없음 따라서 원점을 (0, 0)에서 (5, 5)로 바꿔 음수 좌표 문제를 해결

def is_vaild_move(nx, ny):
    return 0 <= nx < 11 and 0 <= ny < 11

def update_location(x, y, dir):
    if dir == 'U':
        nx, ny = x, y + 1
    elif dir == 'D':
        nx, ny = x, y - 1
    elif dir == 'L':
        nx, ny = x - 1, y
    elif dir == 'R':
        nx, ny == x + 1, y
    return nx, ny

def solution(dirs):
    x, y = 5, 5
    ans = set() # 겹치는 좌표는 1개로 처리
    for dir in dirs:
        nx, ny = update_location(x, y, dir)
        if not is_vaild_move(nx, ny): # 벗어난 좌표는 인정 안함
            continue
        # A에서 B로 간 경우 B -> A 추가
        ans.add((x, y, nx, ny))
        ans.add((nx, ny, x, y))
        x, y = nx, ny # 좌표를 이동했으므로 업데이트
    return len(ans)/2

A -> B, B -> A는 같은 경로로 취급 따라서 둘 다 추가하고 최종 길이를 2로 나눔

시간 복잡도

• N은 dirs의 길이
• dirs의 길이만큼 순회하므로 시간 복잡도는 O(N)

https://programmers.co.kr/learn/courses/30/lessons/42889 슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다.

이 문제를 어떻게 할까 고민 한 그녀는 동적으로 게임 시간을 늘려서 난이도를 조절하기로 했다. 역시 슈퍼 개발자라 대부분의 로직은 쉽게 구현했지만, 실패율을 구하는 부분에서 위기에 빠지고 말았다. 오렐리를 위해 실패율을 구하는 코드를 완성하라.

• 실패율은 다음과 같이 정의한다.
  • 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수

전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라.

권장 시간: 60분 권장 시간 복잡도: O(M+NlonN) 출제: 2019 KAKAO BLIND RECRUITMENT

제약 조건

• 스테이지 개수 N은 1 이상 500 이하 자연수
• stages의 길이는 1 이상 200,000 이하
• stages에는 1 이상 N+1 이하의 자연수가 있음
  • 각 자연수는 사용자가 현재 도전 중인 스테이지 번호를 나타냄
  • 단, N+1은 마지막 스테이지, 즉, N까지 클리어한 사용자를 나타냄
• 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오면 됌
• 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0으로 정의

입출력 예 N | stages | result 5 | [2, 1, 2, 6, 2, 4, 3, 3] | [3,4,2,1,5] 4 | [4,4,4,4,4] | [4,1,2,3]

입출력 예 설명

입출력 예 #1 1번 스테이지에는 총 8명의 사용자가 도전했으며, 이 중 1명의 사용자가 아직 클리어하지 못했다. 따라서 1번 스테이지의 실패율은 다음과 같다.

• 1 번 스테이지 실패율 : 1/8

2번 스테이지에는 총 7명의 사용자가 도전했으며, 이 중 3명의 사용자가 아직 클리어하지 못했다. 따라서 2번 스테이지의 실패율은 다음과 같다.

• 2 번 스테이지 실패율 : 3/7

마찬가지로 나머지 스테이지의 실패율은 다음과 같다.

• 3 번 스테이지 실패율 : 2/4
• 4번 스테이지 실패율 : 1/2
• 5번 스테이지 실패율 : 0/1

각 스테이지의 번호를 실패율의 내림차순으로 정렬하면 다음과 같다.

[3,4,2,1,5] 입출력 예 #2

모든 사용자가 마지막 스테이지에 있으므로 4번 스테이지의 실패율은 1이며 나머지 스테이지의 실패율은 0이다.

[4,1,2,3]

풀이

def solution(N, stages):
    # 스테이지별 도전자 수
    challenger = [0] * (N + 2)
    for stage in stages:
        challenger[stage] += 1

    # 스테이지별 실패한 사용자 수
    fails = {}
    total = len(stages)

    # 실패율 계산
    for i in range(1, N+1):
        # 도전한 사람이 없으면 0
        if challenger[i] == 0:
            fails[i] = 0
        else:
            fails[i] = challenger[i] / total # 실패율
            total -= challenger[i] # 다음 스테이지 실패율 계산을 위한 다음 스테이지 인원 뺴기

    # 실패율이 높은 스테이지부터 내림차순으로 정렬
    result = sorted(fails, key=lambda x : fails[x], reverse=True)
    return result

1. stages에는 플레이어가 어느 스테이지에 있는지에 대한 정보가 있음 따라서 반복문을 따라 순회하며 challengers[stage] 값을 증가시키면 결국 challenger에 각 stage에 있는 플레이어의 수를 저장 가능

• 리스트의 크기를 N + 2로 정한 이유
  • N번째 스테이지를 클리어한 사용자는 stage가 N + 1
  • 배열의 인덱스는 0부터 시작하므로 N + 1의 데이터를 저장하려면 N + 2크기의 배열이 필요
  • 0번째 인덱스를 사용하지 않기에 낭비라 생각되지만 값 자체를 인덱스로 활용가능해 매우 편리해짐

2. fails - 실패율 저장 total - 총 사용자의 수
3. 실패율을 구하는 로직 위에서 구한 challengers값을 활용
4. 해당 스테이지에 있는 사용자가 0이라면 문제 정의에 의해 실패율은 0
5. 해당 스테이지에 사용자가 있다면 실패율 공식을 적용하여 실패율을 구함 fails는 리스트가 아닌 딕셔너리 fails[i] = challenger[i] / total에서 키 - i challenger[i] / total - 값
6. N번째 스테이지에 도달한 사용자의 수를 구하려면 N-1번째 스테이지에 있는 사용자 수를 빼면 됌
7. fails는 딕셔너리 키는 각 스테이지를 가리키는 숫자값은 실패율을 의미 값을 기준으로 키를 정렬해서 반환

시간 복잡도

• N은 스테이지 개수, M은 stages의 길이
• challenger 배열을 초기화하고 각 스테이지 도전자 수를 계산할 때 시간 복잡도는 O(N + M)
• 이후 스테이지 별로 실패율을 계산하는데 필요한 시간 복잡도 O(N)
• 실패율을 기준으로 스테이지를 정렬할 때의 시간 복잡도 O(NlogN)
• O(2N + M + NlogN)이므로 최종 시간 복잡도는 O(M+NlogN)

https://programmers.co.kr/learn/courses/30/lessons/12949 2차원 행렬 arr1과 arr2를 입력받아, arr1에 arr2를 곱한 결과를 반환하는 함수, solution을 완성하시오.

권장 시간: 40분 권장 시간 복잡도: O(N^3) 출제: 연습문제

제약 조건

• 행렬 arr1, arr2의 행과 열의 길이는 2 이상 100 이하입니다.
• 행렬 arr1, arr2의 원소는 -10 이상 20 이하인 자연수입니다.
• 곱할 수 있는 배열만 주어집니다.

풀이

1. arr1, arr2의 행, 열 정보를 변수에 기록하고 행렬 정의를 활용해 결과 행렬을 저장할 수 있는 크기의 새 행렬을 만들어 0으로 초기화

2. 결과 행렬의 크기는 (r1, c2)이므로 해당 크기의 리스트를 미리 만들어 0으로 초기화

3. 행렬의 곱을 위한 반복문

4. 첫 번째 행렬의 i번째 행과 두 번째 행렬의 j번째 열을 곱함

   def solution(arr1, arr2):
    # 행렬 arr1과 arr2의 행과 열 수
    r1, c1 = len(arr1), len(arr1[0])
    r2, c2 = len(arr2), len(arr2[0])
   
    # 결과를 저장할 2차원 리스트 초기화
    ret = [[0] * c2 for _ in range(r1)]
   
    # 첫 번째 행렬 arr1의 각 행과 두 번째 행렬 arr2의 각 열에 대해
    for i in range(r1):
        for j in range(c2):
            # 두 행렬의 데이터를 곱해 결과 리스트에 더해줌
            for k in range(c1):
                ret[i][j] += arr1[i][k] * arr2[k][j]
    return ret

시간 복잡도

• N은 행 또는 열의 길이
• 행과 열의 길이는 같음 arr1의 행, 열을 r1, c1 arr2의 행, 열을 r2, c2라 했을 때 r1c1c2만큼 연산
• 최종 시간 복잡도는 O(N^3)

https://programmers.co.kr/learn/courses/30/lessons/42840

수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ... 2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ... 3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성하시오.

권장 시간: 30분 권장 시간 복잡도: O(N) 출제: 완전 탐색

제약 조건

• 시험은 최대 10,000 문제
• 문제의 정답은 1, 2, 3, 4, 5 중 하나
• 가장 높은 점수를 받은 사람이 여럿이라면 반환하는 값을 오름차순으로 정렬

풀이

1. 패턴을 미리 리스트에 저장(특정 값이나 패턴이 주어지면 하드 코딩하는게 좋음)
2. 패턴과 답안을 비교해서 일치하는 개수를 지정하는 리스트를 선언
3. 각 정답지에 패턴을 매치하여 맞춘 정답 개수를 구해 score에 저장
4. 반복문에서 가장 높은 점수 저장
5. 가장 큰 점수를 갖는 수포자들을 찾아 리스트에 담아 반환

def solution(answers):
    patterns = [
        [1,2,3,4,5],
        [2,1,2,3,2,4,2,5],
        [3,3,1,1,2,2,4,4,5,5]
    ]
    # 점수 저장 리스트
    scores = [0] * 3

    # 패턴, 정답 일치 확인
    for i, answers in enumerate(answers):
        for j, patterns in enumerate(patterns):
            # 정답 패턴 길이가 답안 길이보다 긴 경우 정답 처음 데이터와 다시 비교
            if answers == patterns[i % len(patterns)]:
                scores[j] += 1

    # 가장 높은 점수 저장
    max_score = max(scores)

    # 가장 높은 점수를 가진 수포자들의 번호를 찾아 리스트에 저장
    highest_scores = []
    for i, score in enumerate(scores):
        if score == max_score:
            highest_scores.append(i + 1)
    return highest_scores

enumerate() 함수 인자로 넘어온 목록을 기준으로 인덱스와 원소를 차례대로 접근하게 해주는 반복자(iterator) 객체를 반환해주는 함수

시간 복잡도

• N은 answers의 길이
• 각 수포자들의 패턴과 정답을 비교하는 부분은 O(N)
• 이 후 scores를 순회하며 가장 높은 수포자를 추가하는 연산은 O(1)
• 따라서 최종 시간 복잡도는 O(N)

https://programmers.co.kr/learn/courses/30/lessons/68644

정수 배열 numbers가 주어집니다. numbers에서 서로 다른 인덱스에 있는 2개의 수를 뽑아 더해 만들 수 있는 모든 수를 배열에 오름차순으로 담아 반환하는 solution() 함수를 완성하시오

정답률: 68% 권장 시간: 30분 권장 시간 복잡도: O(N^2log(N^2)) 출제: 월간 코드 챌린지

제약 조건

• numbers의 길이는 2 이상 100 이하입니다.
• numbers의 모든 수는 0 이상 100 이하입니다.

풀이

1. 배열에서 두 수를 선택하고 이에 대한 합을 구함
2. 1에서 구한 수를 새로운 배열에 저장하고 중복값 제거
3. 배열을 오름차순으로 정렬하고 반환

def solution(numbers):
    answer = []
    # 두 수를 선택하는 모든 경우의 수를 반복문으로 구함
    for i in range(len(numbers)):
        for j in range(i + 1, len(numbers)):
            # 두 수를 더한 결과를 새로운 배열에 추가
            answer.append(numbers[i] + numbers[j])
    # 중복된 값을 제거하고, 오름차순 정렬
    answer = sorted(set(ret))
    return answer

print(solution([2, 1, 3, 4, 1])) # 반환값 : [2, 3, 4, 5, 6, 7]
print(solution([5, 0, 2, 7])) # 반환값 : [2, 5, 7, 9, 12]

시간 복잡도

• N은 numbers의 길이
• 이중 반복문으로 모든 원소들에 대해 두 수의 합을 구하는 연산의 시간 복잡도는 O(N^2)
• 이를 set으로 만들 때 시간 복잡도 O(N^2)
• N^2의 데이터 정렬에는 O(N^2log(N^2))의 시간 복잡도가 필요

N = 100이므로 시간 복잡도를 이렇게 해도 문제를 푸는데 큰 영향 x

정수 배열을 하나 받아 배열의 중복값을 제거하고 배열 데이터를 내림차순으로 정렬해서 반환하는 solution()함수를 구현하시오

권장 시간: 10분 권장 시간 복잡도: O(NlogN) 출제: 저자 출제

제약 조건

• 배열 길이는 2 이상 100,000 이하입니다.
• 각 배열의 데이터 값은 -100,000 이상 100,000 이하입니다.

풀이

1. 중복값 제거

set()

• 집합을 생성하는 내장함수(집합은 중복값을 허용하지 않음)
• 배열의 중복값 제거

2. 내림차순 정렬

sort() -> reverse=True(내림차순)

def solution(lst):
    nlist = list(set(lst))
    nlist.sort(reverse=True)
    return nlist

print(solution([4, 2, 2, 1, 3, 4])) # 반환값 : [4, 3, 2, 1]
print(solution([2, 1, 1, 3, 2, 5, 4])) # 반환값 : [5, 4, 3, 2, 1]

시간 복잡도

• N은 lst의 길이
• lst의 중복 원소를 제거하는데 걸리는 시간 복잡도는 O(N)
• 다시 정렬하는데 걸리는 시간 복잡도는 O(NlogN)

정수 배열을 오름차순 정렬해서 반환하는 solution() 함수를 완성하시오

권장 시간: 10분 권장 시간 복잡도: O(NlogN) 출제: 저자 출제

제약 조건

• 정수 배열의 길이는 2 이상 10^5 이하입니다.
• 정수 배열의 각 데이터 값은 -100,000 이상 100,000 이하입니다.

-> 데이터 개수가 초대 10^5이기 때문에 제한시간이 3초라면 O(N^2)알고리즘은 사용이 불가능 단순히 내림, 오름차순으로 정렬하면 틀림

풀이

def solution(arr):
    arr.sort()
    return arr

print(solution([1,-5,2,4,3])) # 반환값 : [-5, 1, 2, 3, 4]
print(solution([2,1,1,3,2,5,4])) # 반환값 : [1, 1, 2, 2, 3, 4, 5]
print(solution([1,6,7])) # 반환값 : [1, 6, 7]

sort() 메서드

• 리스트를 오름차순으로 정렬해서 반환
• 리스트 원본 자체의 값을 바꿈

# 원본 리스트 그대로 두기
def solution(arr):
    sorted_list = sorted(arr)
    return sorted_list

sorted() 메서드

• 원본을 건드리지 않고, 정렬된 새로운 리스트를 만들어서 반환

시간 복잡도

• N은 arr의 길이이므로 O(NlogN)

• 기존의 Supervised Learning은 양질의 label 정보를 충분히 가지고 있는 데이터를 사용해야만 최적의 model을 만들 수 있었음.
• 양질의 데이터 및 label 정보를 얻는 것은 시간과 돈이 많이 필요함.
• 이러한 문제를 극복하기 위해 데이터에서 얻을 수 있는 정보를 사용해서 자체적인 label을 얻기 위해 고안된 방법이 Self-Supervised Learning

• Self-Supervised Learning 은 딥러닝 분야에서 최근 가장 핫한 토픽 중 하나
• Self-Supervised Learning은 그 자체로 분류 및 예측 task의 정확도를 높이는 것이 목적이 아님. Backbone 모델에서 더 좋은 representation(feature)을 학습하고 추출할 수 있도록 하여 차후 task에서 성능을 올리는 것이 목적.
• 이를 위한 초기 연구들은 보통 Jigsaw Puzzle나 Rotation 등의 간단한 Pretext Task를 직접 선정하여 backbone 모델을 학습시키는 것이었음.
• 최근 Self-Supervised Learning 연구 동향은 Pretext Task 없이 Contrastive Learning을 통해 학습하는 것

Backbone 모델

• 이미지의 feature를 추출하는 기본 신경망 구조
• SimCLR에서는 ResNet-50이 backbone으로 사용

representation(feature)

• backbone (예: ResNet)으로부터 나온 feature를 representation이라고도 부름
• SimCLR에서는 실제로 feature를 z가 아닌 h로 사용

task 모델이 해결하려는 실제 문제

pretext task 사전 학습용 인위적인 문제

Contrastive Learning(대조 학습)

• 학습 데이터의 쌍(pair) 사이의 관계를 학습해서 feature space 상의 구조를 정렬하는 방식

• 입력 데이터 쌍 (x₁, x₂)을 만들어서 같은 클래스를 나타내는 쌍이면 → 가까워지게 다른 클래스를 나타내는 쌍이면 → 멀어지게

1. Introduction

• Representation을 학습한다는 것은 쉽게 말해, 인간의 간섭 없이 모델이 스스로 task에 적합한 feature들을 알아낸다는 것

• 학습과정에서 data augmentation과의 차이를 학습하고 embedding layer를 깊게 쌓음으로써 유사도를 비교하는 공간인 feature space를 더 개선하여 image representation 학습 성능을 크게 향상 시키는 데에 기여

• 중요한 사항

1. 간단한 몇 개의 Data augmentation 조합이 SimCLR 구조에서 중요한 역할을 함
2. Representation과 Contrastive loss 사이의 non-linear transformation이 representation 성능을 향상 -> ResNet이 뽑은 feature (representation)를 바로 contrastive loss에 넣는 것보다, 한 번 비선형 함수(MLP 등)를 거쳐서 넣는 게 feature 성능이 더 좋다
3. Contrastive learning은 batch size와 training step(또는 epoch)이 클 때 효과적임

embedding 원본 데이터를 수치화된 의미 공간으로 매핑하는 과정

Contrastive loss 비슷한 쌍은 가깝게, 다른 쌍은 멀게” 학습하기 위한 손실 함수 SimCLR에서는 NT-Xent (Normalized Temperature-scaled Cross Entropy) Loss를 사용

2. Method

SimCLR contrastive learning의 전체 framework를 나타내는 그림

T : Data augmentation 종류 (RandomResizeCrop, Random Color distortion, Gaussian Blur) t,t′ : Random sampling된 Data augmentation 기법 xi,xj : Augmentation된 이미지 f(⋅) : Base Encoder (ResNet-50) hi,hj : ResNet-50 output에서 Global Average Pooling(GAP) 된 vector

• feature map은 3차원 (7×7 공간, 2048 채널)이라서 classifier나 projection head에 넣기 어려움
• GAP : 각 채널마다 공간 평균을 내서 1개의 숫자로 줄이는 연산 즉, [7×7×2048] → [1×1×2048] → 2048차원 벡터로 압축

g(⋅) : non-linear representation을 적용하는 Projection head (Two-layer MLP) zi,zj : Projection head 통과 후 생성된 vector Contrastive loss function : zi,zj간의 NT-Xent Loss

2-1. Training

Training

• Batch size: 256 ~ 8192
• LARS optimizer 사용 : 많은 Batch size 학습을 감당하기 위해
• Aggregating BN mean and variance over all devices -> 멀티 GPU 학습 중에 BatchNorm(BN)의 평균과 분산을 GPU 전체에서 모아서 계산

Dataset

• ImageNet 2012

Evaluation

• Linear Evaluation Protocol : representation까지의 parameter를 freeze하고 linear layer 하나만 추가하여 supervised learning, evaluation 진행

• self-supervised로 학습된 feature extractor(=Backbone)는 고정(freeze)시키고, 그 위에 Linear classifier 하나만 붙여서 supervised task (예: 분류)를 수행해보는 평가 방법

Layer, classifier?

Layer

• 딥러닝 모델을 구성하는 기본적인 구성요소 ex) Linear layer ,Convolutional layer, ReLU, BatchNorm, Dropout 등
• 모든 classifier는 layer

classifier

• 모델의 맨 끝에 위치해서 입력된 feature를 class로 구분하는 역할
• 보통은 Linear layer + softmax 조합으로 이루어짐
• 모든 layer가 classifier는 아님

3. Data Augmentation for Contrastive Representation Learning

간단한 몇 개로 구성된 Data Augmentation 기법 선택이 매우 중요했다고 함

Random cropping, Random color distortion, Gaussian blur 만을 사용하였을 때 가장 성능이 좋음 색상 왜곡 강도를 높일수록 정확도가 증가 + Gaussian blur를 추가했을때 가장 높은 성능을 보였음 -> Contrastive learning에서는 강한 색상 변형이 매우 중요

4.Architectures for Encoder and Head

Non-linear projection head > linear projection head > None

5. Loss Function and Batch Size

Loss Function 중 NT-Xent (Normalized Temperature-scaled Cross Entropy)의 성능이 가장 높았음

Batch Size를 매우 키우는 것이 더 좋은 성능을 보이고 있다. 이는 batch size를 매우 늘릴 경우 그 안에서 충분한 양의 negative sample을 뽑을 수 있기 때문이라고 추론해 볼 수 있다.

6. Comparison with State-of-the-art

여러 Self-Supervised model과의 Linear evaluation 결과를 비교하였을 때, Architecture 별로 ResNet-50을 사용한 결과와 더 깊은 구조를 사용했을 때의 결과 모두 SimCLR에서 가장 뛰어난 성능을 보인다. Self-supervised 외에 transfer learning, semi-supervsied learning에 대한 실험에서도 우수한 성능을 보이고 있다. Semi-supervised learning에 대한 실험 결과 Transfer learning에 대한 실험 결과

7. Related Work

Handcrafted pretext tasks Contrastive visual representation learning

8. Conclusion

Self-supervised Learning Simple framework로 Self-supervised learning, Semi-supervised learning, Transfer learning의 성능을 크게 개선하였다.

Supervised learning과는 다른 augmentation과 non-linear projection head를 제안하였다.

Representation을 학습하는 것으로 Supervised learning 수준의 성능을 달성하였다.

기존의 Pretext task를 활용하지 않고 Memory Bank 또한 필요로 하지 않는다.

이미지에서 필요한 정보만 남기고 노이즈와 같은 불필요한 정보는 걸러내는 작업

• 필터링한 이미지는 주로 영상에서 객체 인식과 같은 다른 작업을 위한 전처리 단계로 활용
• 주파수 공간에서 필터링(주로 사용), 이미지 공간에서 필터링
• 물체의 윤곽선이나 모서리 같은 부분이 고주파, 이웃한 픽셀들과 색상의 차이가 적은 부분이 저주파

9.1 평균 필터링

9.2 메디안 필터링

cv2.medianBlur()는 가장자리 보존하면서 노이즈 제거가 필요한 경우에 적합합니다.

특히 점처럼 생기는 "소금-후추 노이즈(Salt-and-Pepper Noise)"에 매우 효과적입니다.

cv2.GaussianBlur()보다 경계 보존이 잘되는 특징이 있습니다.

9.3 가우시안 필터링

cv2.imread()는 BGR 형식으로 이미지를 읽기 때문에, matplotlib.pyplot.imshow()로 표시할 때 cv2.cvtColor(..., cv2.COLOR_BGR2RGB)로 변환이 필요합니다.

plt.subplot(1, 2, n)은 가로 2개 그림 중 n번째 위치를 뜻합니다.

cv2.GaussianBlur()는 노이즈 제거와 함께 부드러운 흐림 효과를 제공합니다.

9.4 고역통과 필터링

1. 에지 검출(Sobel 연산자)

Sobel 필터는 미분 연산을 기반으로 이미지의 경계를 검출합니다.

• dx=1, dy=0: 수평 방향 (세로 경계)

• dx=0, dy=1: 수직 방향 (가로 경계)

cv2.GaussianBlur()는 노이즈를 줄여 Sobel 결과의 품질을 높이는 역할을 합니다.

np.hstack()으로 원본, X 에지, Y 에지를 한 화면에 비교 가능하게 나열합니다.

2. 에지 검출(Laplacian 연산자)

Laplacian 연산자는 2차 미분을 사용하여 밝기 변화가 급격한 경계(에지)를 검출합니다.

GaussianBlur는 에지 검출 전에 노이즈를 줄이는 사전 처리 역할을 합니다.

결과를 np.concatenate()로 나란히 출력해 비교가 쉽도록 합니다.

3. 에지 검출(Canny 알고리즘)

cv2.createTrackbar(): 슬라이더를 만들고, 조작할 때마다 지정된 콜백 함수(onChange)가 실행됩니다.

cv2.Canny(): 주어진 최소/최대 임계값으로 엣지를 검출합니다.

minVal: 낮은 임계값 → 약한 에지

maxVal: 높은 임계값 → 강한 에지

이 코드는 실시간으로 임계값을 조정하면서 Canny 결과를 확인할 수 있는 인터랙티브 도구입니다.

7.1 RGB 색 공간

RGB는 Red(빨강), Green(초록), Blue(파랑)의 약자

• 컴퓨터는 이미지를 빨강, 초록, 파랑의 빛의 조합으로 표현
• 예를 들어, 흰색은 R, G, B가 모두 255 (최댓값)일 때 나옴
• 흑백 이미지는 RGB를 하나로 합쳐서 밝기만 표현

🧠 기억 포인트: 이미지는 숫자로 구성된 격자이며, 색상은 RGB 값의 조합

7.2 HSV 색 공간, CIE 색 공간

📌 HSV 색 공간 HSV는 Hue(색상), Saturation(채도), Value(명도) 로 구성된 색 표현 방법

색상(Hue): 색의 종류 (0~179) 채도(Saturation): 색의 선명함 (0은 회색, 255는 선명) 명도(Value): 밝기 (0은 어두움, 255는 밝음)

💡 왜 사용할까? HSV는 사람이 인식하는 방식과 비슷해서 색상 추출, 필터링 등에 편리함

📌 CIE 색 공간 CIE 색 공간은 사람이 느끼는 색을 과학적으로 표현한 국제 표준 색 공간. 색의 물리적 특성과 인간의 시각을 기반으로 만들어짐

주로 색 정확도가 중요한 산업 (인쇄, 의료 등)에서 사용

BGR → HSV 색 공간 변환

7.3 동영상 처리

동영상은 많은 이미지(프레임)가 빠르게 연속해서 보여지는 것 각 프레임을 순차적으로 처리하여 사람, 물체, 움직임을 인식 프레임은 보통 1초에 30장 (FPS: Frames Per Second) 정도

7.4 동영상 정보 획득

OpenCV 같은 라이브러리를 사용하면 동영상 파일의 정보를 얻을 수 있음

프레임 수 (cv2.CAP_PROP_FRAME_COUNT) 프레임 속도 (FPS) 해상도 (가로x세로) 현재 프레임 위치

7.5 동영상 캡쳐 및 저장

웹캠 영상이나 동영상 파일을 읽어서 저장

1. cv2.VideoCapture()로 입력 장치 열기
2. 프레임을 하나씩 읽고 (cap.read())
3. cv2.VideoWriter()로 저장

   7.6 저장된 동영상 플레이하기

   OpenCV로 동영상 파일을 프레임 단위로 읽어 재생

8장 이미지 조절 및 향상

8.1 이미지의 밝기 조절

이미지 밝기를 조절한다는 것은 사진을 더 밝거나 어둡게 만든다는 뜻 밝기 조절 밝기 트랙바

1) 포화현상이란? 포화현상이 일어나는 경우

포화현상(Saturation):

• 이미지를 너무 밝게 하거나 너무 어둡게 해서 최댓값(255)이나 최솟값(0)으로 색이 꽉 차버리는 현상입니다.
• 너무 밝게 하면 → 흰색처럼 보이는 영역이 많아지고, 원래 정보(색)가 사라집니다.
• 너무 어둡게 하면 → 까맣게 변하면서 정보가 날아갑니다.

  2) 포화현상 해결

  1. OpenCV의 cv2.add() 함수는 자동으로 포화 현상을 막아줍니다.
     • 넘치는 값은 255로 고정
     • 부족한 값은 0으로 고정
  2. np.clip()을 써서 직접 조절 bright_img = np.clip(img + 100, 0, 255).astype(np.uint8)

8.2 이미지의 명암대비 조절

명암 대비(Contrast): 밝은 부분은 더 밝게, 어두운 부분은 더 어둡게 만들어서 선명하게 보이도록 하는 것입니다.

• 낮은 대비: 흐릿하고 뿌연 이미지
• 높은 대비: 선명하고 강한 이미지

  ---

원근 변환

8.3 이미지의 히스토그램

8.3.1 히스토그램 평활화

히스토그램 평활화는 이미지의 픽셀 분포를 재분배하여 대비(contrast)를 향상시키는 기법 어두운 이미지를 보다 명확하게 만들 때 자주 사용

기하학적 변환

• 영상을 구성하는 픽셀의 배치 구조를 변경함으로써 전체 영상의 모양을 바꾸는 작업

• 픽셀 값은 그대로 유지하면서 위치를 변경하는 작업

  어파인 변환

• 영상을 평행이동 시키거나 회전, 크기 변환 등을 통해 만들 수 있는 변환을 통칭

• 직선은 그대로 직선으로 나타나고, 직선 간의 길이 비율과 평행 관계는 그대로 유지

• 직사각형 형태의 영상은 어파인 변환에 의해 평행사변형에 해당하는 모양으로 변경

  1) 이동(Translation)

  

  2) 크기 변환(Resizing)

  

• 보간법(interpolation)*

• cv2.INTER_NEAREST: 가장 가까운 픽셀값 사용 (계산 속도 빠름, 품질 낮음, 계단현상 발생 가능)

• cv2.INTER_LINEAR: 선형 보간 (기본값, 보통의 확대/축소용)

• cv2.INTER_CUBIC: 4x4 주변 픽셀 사용한 큐빅 보간 (품질 높음, 속도 느림)

• cv2.INTER_LANCZOS4: Lanczos 알고리즘 사용 (가장 품질 좋음, 가장 느림)

  3) 회전 변환(Rotation)

  

  4) 대칭 변환(Reflction)

  

5) 전단 변환(Shear): 밀림 변환

Shear 변환

• 기울이기(Shear)는 한 방향(수평 또는 수직)으로 픽셀을 밀어 이미지 형태를 기울게 만드는 변환
• 이 코드에서는 x 방향을 기준으로 y 방향으로 픽셀을 이동시키므로, 이미지가 수직으로 기울어짐

원근변환

5장 도형그리기

5.1 선그리기

5.2 사각형그리기

5.3 원그리기

5.4 타원 그리기

5.5 다각형그리기

OpenCV의 주요 기능

• 이미지 처리: 이미지의 기본적인 처리 작업(읽기, 쓰기, 변환)부터 복잡한 처리(필터링, 특징 추출, 이미지 복원 등)까지 지원
• 비디오 처리: 비디오 파일 읽기 및 쓰기, 비디오 스트림 처리, 객체 추적 등의 기능을 제공
• 컴퓨터 비전: 얼굴 인식, 객체 탐지, 광학 문자 인식(OCR), 패턴 인식 등 다양한 컴퓨터 비전 관련 작업을 수행 가능
• 기계 학습: OpenCV는 기본적인 기계 학습 알고리즘(예: k-최근접 이웃, SVM, 의사결정 트리 등)을 제공하며, 이미지 데이터와 함께 사용 가능
• 실시간 컴퓨터 비전: 카메라 스트림을 실시간으로 처리하고, 객체 탐지, 얼굴 인식, 동작 인식 등을 수행 가능

이미지 다루기

• 이미지 파일을 읽고, 보고, 저장하는 방법에 대해서 알아봅니다.
• 관련 함수인 cv2.imread(), cv2.imshow(), cv2.imwrite() 에 대해서 알아 봅니다.

이미지 읽기

우선 openCV모듈을 import합니다.

import cv2

cv2.imread() 함수를 이용하여 이미지 파일을 읽습니다. 이미지 파일의 경로는 절대/상대경로가 가능합니다.

img = cv2.imread('lena.jpg', cv2.IMREAD_COLOR)

py:function - cv2.imread(fileName, flag)

이미지 파일을 flag값에 따라서 읽어들입니다.

:param fileName: 이미지파일의 경로
:type fileName: str
:param flag: 이미지 파일을 읽을 때의 Option.
:type flag: int
:return: image객체 행렬
:rtype: numpy.ndarray

이미지 읽기의 flag는 3가지가 있습니다.

• cv2.IMREAD_COLOR : 이미지 파일을 Color로 읽어들입니다. 투명한 부분은 무시되며, Default값입니다.
• cv2.IMREAD_GRAYSCALE : 이미지를 Grayscale로 읽어 들입니다. 실제 이미지 처리시 중간단계로 많이 사용합니다.
• cv2.IMREAD_UNCHANGED : 이미지파일을 alpha channel까지 포함하여 읽어 들입니다.

3개의 flag대신에 1, 0, -1을 사용해도 됩니다.

img값은 numpy의 ndarray type입니다. numpy는 python에서 수학적 처리를 위한 모듈로 openCV에서도 많이 사용됩니다. img가 어떤 형태의 행렬인지 확인을 해보려면 아래와 같이 입력합니다.

img.shape (206, 207, 3)

이미지는 3차원 행렬로 return이 됩니다. 206은 행(Y축), 207은 열(X축), 3은 행과 열이 만나는 지점의 값이 몇개의 원소로 이루어져 있는지를 나타납니다. 위 값의 의미는 이미지의 사이즈는 207 X 206이라는 의미입니다.

그렇다면 3은 어떤 의미일까요. 바로 색을 표현하는 BGR값입니다. 일반적으로 RGB로 많이 나타내는데, openCV는 B(lue), G(reen), R(ed)로 표현을 합니다.

다음은 읽은 이미지를 보는 방법에 대해서 알아보겠습니다.

이미지 보기

cv2.imshow() 함수는 이미지를 사이즈에 맞게 보여줍니다.

c22.imshow('image', img) cv2.waitKey(0) cv2.destroyAllWindows()

py:function - cv2.imshow(title, image)

읽어들인 이미지 파일을 윈도우창에 보여줍니다.

:param title: 윈도우 창의 Title
:type title: str
:param image: ``cv2.imread()`` 의 return값
:type image: numpy.ndarray

cv2.waitKey() 는 keyboard입력을 대기하는 함수로 0이면 key입력까지 무한대기이며 특정 시간동안 대기하려면 milisecond값을 넣어주면 됩니다.

cv2.destroyAllWindows() 는 화면에 나타난 윈도우를 종료합니다. 일반적으로 위 3개는 같이 사용됩니다.

이미지 저장하기

cv2.imwrite() 함수를 이용하여 변환된 이미지나 동영상의 특정 프레임을 저장합니다.

cv2.imwrite('lenagray.png', gray)

py:function - cv2.imwrite(fileName, image)

image파일을 저장합니다.

:param fileName: 저장될 파일명
:type fileName: str
:param image: 저장할 이미지

컬러 이미지의 R, G, B 채널

컬러 이미지와 그레이스케일 이미지를 각각 불러와 비교하고 저장

컬러 이미지를 불러온 후 OpenCV 함수로 그레이스케일로 변환하여 출력 NumPy만 이용해서 컬러 이미지를 그레이스케일로 변환 수식으로 가중 평균을 사용해 그레이스케일 이미지로 변환 파란색, 초록색, 빨간색 채널의 밝기 변화를 시각적으로 확인할 수 있는 이미지를 생성

🚀 브랜드별 AI 챗봇 도입 사례

🍕 1. 도미노피자 (Domino's Pizza) - 'Dom'

• 활용 플랫폼: Facebook Messenger, Google Assistant, 자체 앱, 웹사이트, 스마트 워치 등
• 기술 스택: AI + NLP (자연어 처리), 음성 인식(STT/TTS), 자체 주문 시스템 API 연동
• 주요 기능:
  • 멀티 채널 자연어 주문: "페퍼로니 피자 라지 사이즈 하나 주문해줘" → 다양한 채널에서 텍스트/음성 주문 처리
  • 최근 주문 간편 재주문
  • 실시간 주문 추적 (Pizza Tracker 연동)
  • 매장 찾기 (위치 기반)
  • Google Assistant 통한 음성 주문 ("Hey Google, talk to Domino's")
• 📈 성과: 챗봇/음성 주문량 증가, 고객 주문 접근성 및 편의성 대폭 향상, 주문 처리 속도 개선

• ✅ 포인트: 다양한 고객 접점(채널) + 음성 인식 기술을 적극 활용하여 주문 진입 장벽을 낮추고 속도와 접근성 극대화. 자체 주문/추적 시스템 API 연동이 핵심.

🍔 2. 버거킹 (Burger King) - Messenger Bot & Assistant Action

• 활용 플랫폼: Facebook Messenger, Google Assistant
• 기술 스택: NLP 기반 챗봇 엔진, 위치 정보 Open API (GPS), 메뉴 정보 API 연동
• 주요 기능:
  • 위치 기반 매장 안내: "내 주변 버거킹 찾아줘" → GPS API 연동으로 근처 매장 정보 제공
  • 자연어 기반 메뉴 검색 및 주문
  • 프로모션 및 쿠폰 정보 제공
  • 영업시간 등 매장 정보 안내
• 📈 성과: 모바일 주문율 상승, 앱/챗봇 내 사용자 체류 시간 및 상호작용 증가, 위치 기반 서비스 통한 매장 방문 유도 효과.

• ✅ 포인트: 외부 위치 정보 Open API와 내부 메뉴/프로모션 API를 연동하여 O2O(Online to Offline) 경험 강화 및 모바일 주문 편의성 증대.

🌯 3. 타코벨 (Taco Bell) – ‘TacoBot’

• 활용 플랫폼: Slack (초기 내부 테스트), 웹, 모바일 앱 연동 가능성
• 기술 스택: NLP 기반 자체 AI 챗봇, 내부 메뉴 시스템 API 연동
• 주요 기능:
  • 자유로운 대화형 주문: "오늘 점심 뭐 먹지?" → 메뉴 추천 및 주문 연계
  • 메뉴 커스터마이징: "치즈 빼고 할라피뇨 추가해줘" → 주문 시 옵션 변경 내용을 API 통해 시스템에 반영
  • 과거 주문 내역 기반 재주문
  • 유머러스하고 친근한 대화 톤 (브랜드 페르소나 반영)
• 📈 성과: Slack 기반 내부 파일럿 테스트에서 직원 만족도 및 사용성 검증, AI 학습 데이터 확보 및 고도화. (초기 단계)

• ✅ 포인트: 메뉴 커스터마이징까지 자연어 대화로 처리하는 정교함. 내부 메뉴 API를 활용하여 복잡한 주문도 처리 가능. 챗봇에 브랜드 캐릭터를 부여하여 사용자 경험 차별화.

☕ 4. 스타벅스 (Starbucks) – ‘My Starbucks Barista’ & Alexa Skill

• 활용 플랫폼: Starbucks 모바일 앱, Amazon Alexa
• 기술 스택:
  • 고도화된 NLP + 음성 인식 (STT/TTS)
  • 자체 Open API 에코시스템 (메뉴, 재고, 결제, 리워드, 매장 정보 등 포괄적 연동)
  • 클라우드 기반 인프라 (e.g., AWS)
• 주요 기능:
  • 음성/텍스트 기반 자연어 주문: "아이스 아메리카노 톨 사이즈 하나, 내 계정으로 결제해줘"
  • 복잡한 커스텀 주문 처리 (샷 추가, 시럽 변경 등)
  • Starbucks Rewards 연동: 별 적립, 잔액 확인, 리워드 사용, 자동 결제
  • 최근 주문/선호 메뉴 기반 재주문
  • 매장 위치 및 픽업 시간 지정
• 📈 성과: 충성 고객 대상 반복 주문 증가, 앱 활용도 및 체류 시간 증대, 개인화된 고객 경험 제공, 음성 인터페이스를 통한 주문 편의성 혁신.

• ✅ 포인트: 자체 구축한 포괄적인 Open API 생태계를 기반으로 주문부터 결제, 리워드까지 끊김 없는(Seamless) 경험 제공. 음성 인터페이스를 핵심 기능으로 내세워 고도화된 개인화 서비스 구현.

📊 사례 비교 분석

📌 기능별 비교 요약

(△: 일부 지원 또는 다른 방식/수준으로 제공)

📌 브랜드별 대표 전략 비교

📌 공통점

1. AI 기반 자연어 이해 (NLP)는 기본: 모든 사례에서 사용자의 의도를 파악하고 자연스러운 대화를 가능하게 하는 NLP 기술이 핵심적으로 활용됩니다.
2. 대화형 UI/UX 도입: 챗봇 인터페이스를 통해 메뉴 탐색부터 주문 완료까지의 과정을 더 직관적이고 간편하게 만듭니다.
3. 주문 편의성 혁신: 재주문, 추천, 위치 안내 등 다양한 기능을 통해 고객의 주문 경험을 개선하고 시간을 절약해 줍니다.
4. API 연동을 통한 기능 확장: 단순 대화를 넘어 실제 주문 처리, 위치 정보 확인, 결제, 멤버십 연동 등 복합적인 기능을 구현하기 위해 내부 시스템 또는 외부 서비스와의 API 연동이 필수적입니다. 특히 Open API 활용은 서비스 확장성과 유연성을 높이는 데 기여합니다.
5. 모바일 및 음성 플랫폼 적극 활용: 고객이 가장 많이 사용하는 스마트폰 앱, 메신저, AI 스피커 등을 통해 서비스를 제공하여 접근성을 높입니다.

pip install pandas

판다스 데이터 객체

DataFrame 객체

DataFrame 객체는 행과 열로 이루어진 2차원 데이터를 다루기 위한 객체입니다. 열은 각각의 변수를 나타내고, 행은 각각의 관측치를 나타냅니다. DataFrame 객체는 여러 가지 방법으로 생성할 수 있습니다.

# 리스트를 사용하여 DataFrame 객체 생성하기
import pandas as pd

data = [['A', 1], ['B', 2], ['C', 3]]
df = pd.DataFrame(data, columns=['col1', 'col2'])
print(df)
# 출력 결과
#   col1  col2
# 0    A     1
# 1    B     2
# 2    C     3

# 딕셔너리를 사용하여 DataFrame 객체 생성하기

data = {'col1': ['A', 'B', 'C'], 'col2': [1, 2, 3]}
df = pd.DataFrame(data)
print(df)
# 출력 결과
#   col1  col2
# 0    A     1
# 1    B     2
# 2    C     3

# CSV 파일을 사용하여 DataFrame 객체 생성하기
df = pd.read_csv('data.csv')
print(df)

Series 객체

Series 객체는 인덱스와 값으로 이루어진 1차원 데이터를 다루기 위한 객체입니다. Series 객체는 DataFrame 객체에서 열을 선택하여 추출할 수 있습니다.

# 리스트를 사용하여 Series 객체 생성하기
import pandas as pd

data = [1, 2, 3]
s = pd.Series(data, index=['a', 'b', 'c'])
print(s)
# 출력 결과
# a    1
# b    2
# c    3
# dtype: int64

# 딕셔너리를 사용하여 Series 객체 생성하기
data = {'a': 1, 'b': 2, 'c': 3}
s = pd.Series(data)
print(s)
# 출력 결과
# a    1
# b    2
# c    3
# dtype: int64

판다스 기본 사용법

데이터 불러오기

판다스에서는 다양한 형태의 데이터를 불러올 수 있습니다. 대표적인 데이터 형식으로는 CSV, Excel, SQL 등이 있습니다.

CSV 파일 불러오기

• CSV(Comma-Separated Values) 파일은 쉼표로 구분된 데이터를 저장하는 파일 형식입니다. 판다스에서는 read_csv() 함수를 이용하여 CSV 파일을 불러올 수 있습니다.

import pandas as pd

# CSV 파일 불러오기
df = pd.read_csv('data.csv')

Excel 파일 불러오기

• Excel 파일은 스프레드시트 프로그램에서 생성한 데이터를 저장하는 파일 형식입니다. 판다스에서는 read_excel() 함수를 이용하여 Excel 파일을 불러올 수 있습니다.

import pandas as pd

# Excel 파일 불러오기
df = pd.read_excel('data.xlsx')

데이터 살펴보기

데이터를 불러온 후에는 데이터의 구조와 내용을 살펴볼 필요가 있습니다. 판다스에서는 다음과 같은 함수를 이용하여 데이터를 살펴볼 수 있습니다.

데이터프레임 정보 확인하기

• info() 함수는 데이터프레임의 정보를 출력합니다. 데이터프레임의 크기, 데이터 타입, 결측치 등의 정보를 확인할 수 있습니다.

# 데이터프레임 정보 확인하기
df.info()

데이터프레임 일부 데이터 보기

• head() 함수는 데이터프레임의 첫 n행을 출력합니다. n은 인자로 전달될 수 있습니다. 기본값은 5입니다.

# 데이터프레임 일부 데이터 보기
df.head()

데이터프레임 요약 통계량 보기

• describe() 함수는 데이터프레임의 요약 통계량을 출력합니다. 각 열의 개수, 평균, 표준편차, 최소값, 25% 백분위수, 중앙값, 75% 백분위수, 최대값 등의 정보를 확인할 수 있습니다.

# 데이터프레임 요약 통계량 보기
df.describe()

데이터 선택하기

데이터프레임에서는 특정한 열이나 행을 선택하여 데이터를 조회할 수 있습니다.

열 선택하기

• 특정한 열을 선택할 때는 데이터프레임의 열 이름을 사용합니다.

# 열 선택하기
df['열 이름']

여러 개의 열을 선택할 때는 리스트 형태로 열 이름을 전달합니다.

# 여러 개의 열 선택하기
df[['열 이름 1', '열 이름 2', ...]]

행 선택하기

• 특정한 행을 선택할 때는 loc[] 함수를 사용합니다. loc[] 함수는 행의 이름 또는 인덱스를 사용하여 행을 선택합니다.

# 행 선택하기
df.loc[행 이름 또는 인덱스]

여러 개의 행을 선택할 때는 리스트 형태로 행 이름 또는 인덱스를 전달합니다.

# 여러 개의 행 선택하기
df.loc[[행 이름 또는 인덱스 1, 행 이름 또는 인덱스 2, ...]]

데이터 필터링하기

데이터프레임에서는 특정한 조건을 만족하는 데이터만 선택하여 조회할 수 있습니다.

조건 필터링하기

• 조건 필터링은 [] 연산자와 조건식을 이용하여 수행합니다.

# 조건 필터링하기
df[조건식]

예를 들어, 2010년 이후의 데이터만 선택하고 싶을 때는 다음과 같이 작성할 수 있습니다.

# 2010년 이후의 데이터만 선택하기
df[df['Year'] >= 2010]

논리 연산자 이용하기

• &(and)와 |(or) 연산자를 이용하여 논리 연산을 수행할 수 있습니다.

# 논리 연산자 이용하기
df[(조건식 1) & (조건식 2)]
df[(조건식 1) | (조건식 2)]

예를 들어, 2010년 이후이면서 금메달 이상을 획득한 데이터만 선택하고 싶을 때는 다음과 같이 작성할 수 있습니다.

# 2010년 이후이면서 금메달 이상을 획득한 데이터만 선택하기
df[(df['Year'] >= 2010) & (df['Medal'] == 'Gold')]

isin() 함수 이용하기

• isin() 함수를 이용하여 특정한 값이 포함된 데이터만 선택할 수 있습니다.

# isin() 함수 이용하기
df[df['열 이름'].isin([값1, 값2, ...])]

예를 들어, 'KOR', 'USA', 'JPN' 국가의 데이터만 선택하고 싶을 때는 다음과 같이 작성할 수 있습니다.

# 'KOR', 'USA', 'JPN' 국가의 데이터만 선택하기
df[df['NOC'].isin(['KOR', 'USA', 'JPN'])]

데이터 그룹화하기

데이터프레임에서는 특정한 기준에 따라 데이터를 그룹화하여 처리할 수 있습니다.

groupby() 함수 이용하기

• groupby() 함수를 이용하여 특정한 열을 기준으로 데이터를 그룹화할 수 있습니다.

# groupby() 함수 이용하기
df.groupby('열 이름')

groupby() 함수로 그룹화한 데이터는 각 그룹에 대한 정보를 담고 있는 객체입니다. 이를 바탕으로 다양한 처리를 수행할 수 있습니다.

집계 함수 이용하기

• 그룹화된 데이터에 대해 집계 함수를 이용하여 다양한 처리를 수행할 수 있습니다.

# 집계 함수 이용하기
그룹화된 데이터.집계함수()

그룹화된 데이터에 대해 적용할 수 있는 집계 함수는 다양합니다. 일반적으로 사용되는 집계 함수는 다음과 같습니다.

데이터 정렬하기

데이터프레임에서는 특정한 열을 기준으로 데이터를 정렬할 수 있습니다. 기본적으로 오름차순으로 정렬되며, 내림차순으로 정렬하려면 ascending=False 옵션을 추가합니다.

# 오름차순으로 정렬하기
df.sort_values('열 이름')

# 내림차순으로 정렬하기
df.sort_values('열 이름', ascending=False)

Index 초기화하기

데이터프레임에서는 reset_index() 함수를 이용하여 인덱스를 초기화할 수 있습니다. 이때 기존 인덱스는 열로 추가됩니다.

# 인덱스 초기화하기
df.reset_index()

matplotlib 설치

pip install matplotlib

• import는 관례적으로 다음과 같이 한다.

from matplotlib import pyplot as plt

import numpy as np
import pandas as pd

Font 설정

아무 설정을 하지 않으면 한글이 깨지는 경우가 많다.

RuntimeWarning: Glyph 44256 missing from current font.
  font.set_text(s, 0.0, flags=flags)

보통 다음과 같이 설정해주면 된다.

from matplotlib import rcParams
rcParams["font.family"] = "Malgun Gothic"
rcParams["axes.unicode_minus"] = False

참고로 설정 가능한 폰트 목록을 확인하고 싶다면 다음 코드를 실행해 보자.

import matplotlib.font_manager
fpaths = matplotlib.font_manager.findSystemFonts()
font_names = []
for i in fpaths:
    f = matplotlib.font_manager.get_font(i)
    font_names.append(f.family_name)

print(font_names[:5])

for fn in font_names:
    if 'malgun' in fn.lower():
        print(fn)

예제 데이터

data = pd.DataFrame(data={
    'A': [1,4,3,6,5,8,7,9],
    'B': [6,5,7,8,9,9,8,9],
    'C': [8.8,7.7,6.6,5.5,4.4,3.3,2.2,1.1]
})

그래프 종류

산점도(scatter)

plt.scatter(x=[1,2,3], y=[4,5,6])

선 그래프(plot)

plt.plot(data.index, data['B'])
# 하나만 입력하면 기본 index로 그려진다.
plt.plot(data['C'])

# 한 번의 plot() 호출로 여러 개를 그릴 수 있다. 순서는 x, y, fmt 순으로 입력할 수 있다.
t = np.arange(0., 5., 0.2)
plt.plot(t, t, 'r--', t, t**2, 'bs-', t, t**3, 'g^-.')

plot()은 list나 DataFrame뿐 아니라 dictionary도 그래프로 나타낼 수 있다.

data_dict = {'x': [1, 2, 3, 4, 5], 'y': [2, 3, 5, 7, 11]}
plt.plot('x', 'y', data=data_dict)

막대 그래프(bar)

plt.bar(data.index, data['B'])

2개 그룹 동시 표시 stack해서 사용하는 방법은 다음과 같이 bottom 옵션을 사용한다.

p1 = plt.bar(data.index, data['B'], color='red', alpha=0.7)
p2 = plt.bar(data.index, data['C'], color='blue', alpha=0.7, bottom=data['B'])
# plot이 여러 개인 경우 plt.legend()는 그냥 넣으면 legend가 출력되지 않는다.

나란히 놓는 방법은 bar의 width 옵션과 x좌표를 조정하면 된다.

p1 = plt.bar(data.index-0.2, data['B'], color='red', alpha=0.7, width=0.4)
p2 = plt.bar(data.index+0.2, data['C'], color='blue', alpha=0.7, width=0.4)
plt.legend((p1, p2), ('B', 'C'), fontsize=12)

boxplot

x = np.random.normal(50, 5, 100)
plt.boxplot(x)

여러 boxplot을 한 번에 그리려면 리스트에 담아서 전달한다.

x1 = np.random.normal(15, 5, 500)
x2 = np.random.normal(10, 10, 100)
plt.boxplot([x1, x2])
plt.xticks([1, 2], ["x1", "x2"])

Histogram

구간 개수는 bins으로 설정한다.

x = np.random.normal(10, 2, 100)
plt.hist(x, bins=10)

스타일 설정

• dashes - 직접 dash line을 조작할 수 있다.
• markevery - 마커를 만들 샘플을 추출할 수 있다. 옵션값이 5(int)면 5개의 샘플마다, float이면 상대적 거리에 따라 추출한다.
• visible - 선을 안 보이게 할 수 있다.
• fillstyle - 마커를 채우는 방식을 설정할 수 있다. full, left, right, bottom, top, none 가능

format string(fmt)

색상, 마커, 선 스타일을 쉽게 지정할 수 있다.

plt.plot(data['A'], 'b.-', label='A')
plt.plot(data['B'], 'cv--', label='B') 
plt.plot(data['C'], 'm|:', label='C')
plt.legend()

색상(color)

plt.plot(data['B'], label='B', color='red')
plt.plot(data['C'], label='C', color='green')
plt.legend()

선 스타일(linestyle), 두께(linewidth)

• 선 스타일은 linestyle parameter를 전달하며 기본값인 solid와 dashed, dotted, dashdot이 있다.
• 선 두께는 linewidth로 설정하고 기본값은 1.5이다.

  plt.plot(data['A'], label='A', linestyle='dashed', linewidth=2)
  plt.plot(data['B'], label='B', linestyle='dotted', linewidth=3)
  plt.plot(data['C'], label='C', linestyle='dashdot', linewidth=4)
  plt.legend()

  

수치로 직접 지정할 수 있다. 참고로 (0, (1, 1))은 dotted, (0, (5, 5))는 dashed, (0, (3, 5, 1, 5))는 dashdot과 같다.

plt.plot(data['A'], label='A', linestyle=(0, (1,1)), linewidth=2)
plt.plot(data['B'], label='B', linestyle=(0, (4,1)), linewidth=3)
plt.plot(data['C'], label='C', linestyle=(0, (1,4)), linewidth=4)
plt.legend()

bar 스타일(width, color, linewidth)

bar의 두께를 설정할 수 있다. 각 데이터마다 다른 값을 주면 각각 다르게 설정할 수도 있다.

plt.bar(data.index, data['A'], width=0.4, color=["red", "blue", "green", "purple", "red", "blue", "green", "purple"], linewidth=2.5)

마커(marker)

각 data point마다 marker를 표시할 수 있다.

• 점: ., 원: o, 사각형: s, 별: *, 다이아몬드:D, d
• marker의 사이즈도 markersize parameter로 지정할 수 있다.
• 산점도(scatter)의 마커 크기는 s parameter로 설정한다. 단 크기가 10배 차이난다.

plt.plot(data['A'], label='A', marker='o', markersize=4)
plt.plot(data['B'], label='B', marker='s', markersize=8)
plt.scatter(data.index, data['C'], label='C', marker='.', s=120, color='red')
plt.legend()

투명도(alpha)

데이터가 너무 많은 경우 투명도를 조절하면 좀 더 잘 보이게 할 수 있다.

import numpy as np
x = np.random.normal(0, 1, 16384)
y = np.random.normal(0, 1, 16384)
plt.scatter(x, y, alpha = 0.04, color='purple')

그래프 전체 설정

그래프 크기 설정

plt.figure(figsize=(6, 3))
plt.scatter(x=data.index, y=data['A'])

그래프 제목(title)

plt.scatter(x=data.index, y=data['A'])
plt.title("Gorio")

범례 설정(legend)

기본적으로 plot(label=...) 등으로 label을 등록하면,plt.legend()로 등록된 label들을 표시해주는 개념이다.

plt.scatter(x=data.index, y=data['A'], label='Gorio')
plt.legend()

legend 위치는 그래프를 가리지 않는 위치에 임의로 생성된다. 위치를 지정하려면 loc parameter를 설정한다.

plt.scatter(x=data.index, y=data['A'], label='Gorio')
plt.legend(loc='lower right')

가능한 옵션 left, center, right, upper left, upper center, upper right, lower left, lower center, lower right

loc=(0.5, 0.5)와 같이 직접 수치를 지정할 수도 있다. loc=(0.0, 0.0)은 왼쪽 아래, loc=(1.0, 1.0)은 오른쪽 위이다.

legend() 메서드에서도 label을 직접 등록하여 표시할 수 있다.

p1 = plt.bar(data.index-0.2, data['A'], color='red', alpha=0.7, width=0.4)
p2 = plt.bar(data.index+0.2, data['C'], color='blue', alpha=0.7, width=0.4)
plt.legend((p1, p2), ('A', 'C'), fontsize=12)

ncol 옵션으로 범례에 표시되는 텍스트의 열 개수를 지정할 수 있다.

p1 = plt.bar(data.index-0.2, data['A'], color='red', alpha=0.7, width=0.4, label='A')
p2 = plt.bar(data.index+0.2, data['C'], color='blue', alpha=0.7, width=0.4, label='C')
plt.legend(ncol=2)

x, y축 설정

축 제목(xlabel, ylabel)

plt.scatter(x=data.index, y=data['A'])
plt.xlabel("x axis")
plt.ylabel("y axis")

축 제목과 축 간 거리는 labelpad로 조정한다.

plt.plot(data.index, data['A'])
plt.xlabel("x axis", labelpad=20)
plt.ylabel("y axis", labelpad=-1)

축 범위 설정(xlim, ylim, axis)

각 함수를 호출하면 return value로 x축, y축, x 및 y축의 최솟값/최댓값을 얻을 수 있다.

plt.scatter(x=data.index, y=data['A'])
xmin, xmax = plt.xlim(left=0, right=10)
ymin, ymax = plt.ylim(bottom=0, top=10)
# 아래 한 줄로도 쓸 수 있다.
# xmin, xmax, ymin, ymax = plt.axis([0,10,0,10])

left, right, bottom, top 중 설정하지 않은 값은 데이터 최솟값/최댓값에 맞춰 자동으로 설정된다.

범위를 수치로 직접 설정하는 대신 그래프의 비율이나 scale을 조정할 수 있다. scaled의 경우 다음과 같이 x축 간격과 y축 간격의 scale이 같아진다.

plt.scatter(x=data.index, y=data['A'])
xmin, xmax, ymin, ymax = plt.axis('scaled')
# (-0.35000000000000003, 8.450000000000001, 0.6, 9.4)

옵션: 'on' | 'off' | 'equal' | 'scaled' | 'tight' | 'auto' | 'normal' | 'image' | 'square'

눈금 값 설정(xticks, yticks)

ticks에 tick의 위치를 지정하고, labels에 원하는 tick 이름을 지정할 수 있다.

plt.scatter(x=data.index, y=data['A'])
plt.xticks(ticks=[0,3,6], labels=['zero', 'three', 'six'])
plt.ylim(bottom=0, top=10)

막대그래프는 기본적으로 막대의 중심 좌표를 기준으로 계산하지만 align parameter를 주면 왼쪽 위치로 계산할 수 있다.

plt.bar(data.index, data['B'], align='edge')
plt.xticks([0,3,6], ['zero', 'three', 'six'])

1. 파일 구조

frontend/src/app/
├── api/
│   └── property.ts  (API 연동)
├── components/
│   └── ChatBot.tsx    (챗봇 컴포넌트 - 추후 개발)
├── property/
│   └── [id]/
│       └── page.tsx   (매물 상세 페이지)
└── page.tsx           (메인 페이지)

backend/
├── app/
│   ├── main.py          # FastAPI 서버 실행 (진입점)
│   ├── routes.py        # 매물 조회 + 전세 사기 분석 API
│   ├── database.py      # 간단한 데이터 저장 (리스트 활용)
│   ├── scam_check.py    # 전세 사기 AI 분석 (랜덤 점수 부여)
│   ├── schemas.py       # API 요청/응답 데이터 구조
├── requirements.txt     # 필요한 Python 패키지 목록
├── .env                 # 환경 변수 (DB URL 등)
├── README.md

2. 주요 페이지 흐름

2.1. 홈 화면 (page.tsx)

• 구성 요소:

  • 매물 검색창:
    • 지역, 가격, 면적 등 검색 조건 입력
  • 매물 리스트:
    • 검색 조건에 맞는 매물 목록 표시
    • 각 매물은 간략한 정보 (이름, 가격, 사진) 표시

• 동작:

  1. 사용자 접속: page.tsx 로드
  2. 매물 검색: 사용자가 검색 조건 입력 후 검색
  3. 매물 리스트 갱신: 검색 조건에 맞는 매물 리스트 표시
  4. 매물 선택: 사용자가 특정 매물 클릭
  5. 상세 페이지 이동: property/[id]/page.tsx로 이동 (해당 매물의 id를 파라미터로 전달)

2.2. 매물 상세 페이지 (property/[id]/page.tsx)

• 구성 요소:

  • 매물 기본 정보:
    • 매물 이름, 가격, 면적, 층수, 준공 연도, 사진
    • 매물 상세 설명
  • AI 기반 전세 사기 위험 분석 결과:
    • 전세 사기 위험 점수 (0~100): FastAPI에서 계산
    • 위험 레벨: 점수에 따라 "안전", "주의", "위험" 표시 (색상으로 구분)
    • 상세 분석 내용: (추후 개발)
  • 관심 목록 추가 버튼:
    • 매물을 관심 목록에 추가/제거 가능

• AI 기반 전세 사기 위험 분석 (상세)

  위험 점수	레벨	색상	설명
  0 ~ 30	안전	초록색	전세 사기 위험이 낮은 안전한 매물입니다.
  31 ~ 70	주의	주황색	전세 사기 위험이 중간 정도인 매물입니다. 계약 시 주의가 필요합니다.
  71 ~ 100	위험	빨간색	전세 사기 위험이 높은 매물입니다. 계약을 신중하게 고려하십시오.

• 동작:

  1. 페이지 로드: property/[id]/page.tsx 로드 (매물 id 파라미터 전달)
  2. API 호출: 백엔드 API (api/property.ts)를 호출하여 해당 매물의 상세 정보 및 AI 분석 결과를 가져옴
  3. 정보 표시: 매물 기본 정보 및 AI 분석 결과 화면에 표시
  4. 관심 목록 추가/제거: 사용자가 "관심 목록 추가" 버튼 클릭 시, 로컬 스토리지 또는 API를 통해 관심 목록 관리

3. 데이터 흐름

1. 매물 검색:
   • 사용자가 page.tsx에서 검색 조건 입력
   • 검색 조건과 함께 백엔드 API (api/property.ts) 호출
   • 백엔드는 검색 조건에 맞는 매물 데이터 반환
   • page.tsx는 반환된 데이터를 화면에 표시
2. 매물 상세 정보 및 AI 분석 결과:
   • 사용자가 특정 매물을 클릭 (property/[id]/page.tsx 로드)
   • property/[id]/page.tsx는 해당 매물 id와 함께 백엔드 API (api/property.ts) 호출
   • 백엔드는 매물 상세 정보 및 AI 분석 결과 반환
   • property/[id]/page.tsx는 반환된 데이터를 화면에 표시

     ---

홈

상세 페이지 + AI 분석