all is well

[DI Toy Project] KCD-SNOMED CT 자동 매핑 후보 추천시스템

strongyoung — Mon, 19 Jan 2026 13:51:06 +0900

1. 프로젝트 개요

본 프로젝트는 KCD(Korean Classification of Diseases) 질병명을 입력으로 받아, 국제 표준 임상 용어 체계인 SNOMED CT의 개념 후보를 자동으로 추천하는 딥러닝 기반 매핑 후보 추천 시스템을 구축하는 것을 목표로 한다.

국내 의료데이터는 주로 KCD기반으로 관리되고 있으나, 의미 표현의 정밀성, 계층 구조, 개념 간 관계를 충분히 반영하는 데에는 한계가 있다.

반면, SNOMED CT는 임상 의미 중심의 개념 체계로, 의료 정보의 표준화와 상호운용성 확보에 적합한 국제 표준 용어 체계이다.

KCD-SNOMED CT간 매핑은 현재 의료 도메인 전문가의 수작업에 의존하고 있으며, 대규모 코드셋을 지속적으로 관리·갱신하는데 구조적 한계를 가진다.

이에 본 프로젝트는 AI 기반 자동화 방식을 통해 매핑 작업을 보조할 수 있는 시스템을 제안한다.

2. 프로젝트 목표

본 프로젝트의 목표는 다음과 같다.

딥러닝 기반 KCD -> SNOMED CT 자동 매핑 후보 추천시스템 구축
SNOMED CT 구조를 반영한 일관된 전처리 파이프라인 설계
SapBERT 기반 의미 임베딩을 활요한 매핑 정확도 향상

이를 통해 수작업 매핑을 최소화하고, CDM 기반 연구 및 의료데이터 분석 활용을 강화하는 것을 목표로 한다.

3. 사용 데이터셋

프로젝트에는 다음 데이터셋이 사용되었다.

SNOMED CT Release 데이터
- Concept: 의료 개념 기준 테이블
- Description: FSN, Preferred Term, Synonym 정보
- Relationship: 개념 간 is-a 및 속성 관계
KCD DB Master File
- 병원에서 사용하는 KCD 진단 코드 및 질병명
Goldset (A~D)
- 의료 도메인 전문가 검증 기반 정답 매핑 데이터

SNOMED CT의 개념·용어·관계 구조를 통합적으로 활용하여 KCD–SNOMED CT 간 의미 기반 자동 매핑을 수행한다.

4. SNOMED CT 타겟 전처리 전략

SNOMED CT에서 제공하는 Release 파일은다수의 테이블과 복잡한 관계 구조로 구성되어 있어 직접적인 검색·비교에 활용하기 어렵다.

이에 본 프로젝트에서는 Release 파일을 매핑 목적에 맞게 정제하여 검색 공간으로 활용 가능한 SNOMED CT 용어 집합으로 구성하였다. 전처리는 SNOMED CT 용어 집합을 중심(target)으로 수행되었으며, KCD 질병명은 질의(Query)로서 의미 손실을 최소화하기 위해 최소한의 정규화만 적용하였다.

4.1 전처리 단계 요약

1단계. 공통 전처리 규칙 정의

분산된 테이블 구조 정제
의료 도메인 불용어 및 불필요한 표기 제거
괄호 및 부가 설명 제거

2단계. SNOMED CT 특화 전처리

Semantic tag(disorder, finding, procedure 등) 기반 개념 필터링
FSN / Preferred Term / Synonym 구조 보존
acute/chronic, benign/malignant 등 modifier 정보 유지

3단계. 전처리 정보 활용 확장

concept 간 is-a 및 속성 관계 반영
Query relaxation 전략 고도화
임베딩 및 재랭킹 파이프라인과 연계

5. 모델 및 임베딩 전략

SapBERT

의료 도메인 특화 임베딩 모델
UMLS 기반 동의어 및 의미 관계 학습
SNOMED CT, ICD 등 의료 용어 간 의미 유사도 계산에 최적화
FAISS 기반 Top-K 후보 검색에 활용

Semantic-aware BERT

의미 중심으로 학습된 BERT 임베딩 방식
동일 Concept ID에 속한 FSN, Preferred Term, Synonym을
하나의 의미 공간으로 정렬
Re-ranking 단계 전 의미 정밀 비교에 활용

6. 매핑 후보 추천 파이프라인

시스템은 다음과 같은 파이프라인으로 구성된다.

본 파이프라인은 의미 기반 검색과 어휘 기반 검색을 결합하여 단일 자동 분류 방식의 한계를 보완하는 전문가 보조형 매핑 프레임워크로 구성되었다.

7. 평가 지표

모델 성능 평가는 단일 정확도 지표가 아닌,
랭킹 기반 평가 지표를 중심으로 수행되었다.

Accuracy@K: Top-K 내 정답 포함 여부
MRR (Mean Reciprocal Rank): 정답 순위의 역수 평균
NDCG@K: 순위 품질을 고려한 정규화 지표
MAP@K: 평균 정밀도 기반 지표
AvgRank: 정답 평균 순위

8. 실험 결과

K 값이 증가할수록 Accuracy가 지속적으로 상승
Top-10 기준 70% 이상의 정확도 달성
MRR ≈ 0.60 → 정답이 평균적으로 상위 2~3순위에 위치
단일 Top-1 예측보다 랭킹 기반 후보 추천 방식에 적합한 특성 확인

9. 오류 분석 및 한계

대표적인 오류 사례 분석 결과, 모델은 질병명의 표면 의미(예: typhoid, paratyphoid)를 정확히 포착하여 임상적으로 그럴듯한 하위 질환을 우선 선택하는 경향을 보였다.

그러나 일부 사례에서 정답은 상위 개념(Broad concept)에 해당하는 SNOMED CT 개념으로, 이는 의미 유사도 산정의 문제가 아니라 SNOMED CT의 상·하위 계층 구조를 충분히 반영하지 못한 결과로 해석된다.

10. 프로젝트 시사점

SapBERT 기반 의미 임베딩이 의료 질환 간 의미적 근접성을 효과적으로 포착함을 확인
KCD–SNOMED CT 매핑을 분류 문제에서 추천 문제로 재정의
대규모 코드셋 매핑 시 전문가 검토 범위를 Top-K로 축소 가능
수작업 매핑 대비 시간·비용·일관성 측면에서 실질적 개선 가능
의료 도메인 특성에 부합하는 전문가 보조형 매핑 시스템 설계 방향 제시

본 프로젝트는 KCD–SNOMED CT 매핑을 자동화하기 위한 의미 기반·랭킹 기반 접근 방식을 제시하며, 실무 적용을 고려한 후보 추천 시스템의 가능성을 확인하였다.

11. 고도화 아이디어

더불어 전처리를 추가적으로 보완하여 모델 성능 및 매핑 정확도를 높일 수 있을 것으로 기대된다.

Project & ETL Process

strongyoung — Mon, 19 Jan 2026 13:39:00 +0900

1. 프로젝트의 정의

프로젝트의 본질: 정해진 기간(납기) 내에 고객과 약속된 범위(요구사항)를 시스템으로 구현하여 인도하는 과정.

프로젝트란 특정 목표를 달성하기 위해, 고유한 결과물을 만들어내기 위해, 한시적으로 투입되는 일련의 노력을 말하며, 시작과 끝이 정해져 있고 시간, 범위, 비용 등의 제약 속에서 진행됩니다.

프로젝트의 주요 특징

일시적(Temporary): 분명한 시작과 종료 시점이 있습니다.
고유성(Unique): 모든 프로젝트는 이전과는 다른 고유한 제품, 서비스, 혹은 결과물을 창출합니다.
점진적 상세화(Progressive Elaboration): 초기에는 개략적으로 계획되고, 진행될수록 세부 사항이 구체화됩니다.
제약 조건: 시간(Time), 범위(Scope), 비용(Cost)이라는 3가지 핵심 요소의 제약을 받으며 관리됩니다.

2. 의료 데이터 통합 아키텍처 및 흐름

데이터는 생성(기간계) → 임시 저장(ODS) → 분석/활용(CDW)의 흐름을 따릅니다.

단계	시스템 구분	설명	데이터 상태
1단계	기간계/계정계 (Legacy)	실제 업무(진료, 원무 등)가 실시간으로 일어나는 운영 시스템.	Live Data (실시간 변동)
2단계	ODS (Operational Data Store)	ETL을 통해 기간계 데이터를 1:1로 그대로 복사해오는 임시 저장소. 정보계로 넘어가기 전의 중간 기착지.	Raw Data (원천 그대로)
3단계	정보계 / CDW (Clinical Data Warehouse)	데이터를 주제별로 재구성하고 통합하여 분석 및 연구에 활용하는 시스템. (CDW는 의료 분야 특화 DW)	Historical Data (D-1, D-2...)

3. 데이터 동기화 방식 (ETL 및 시차)

시스템 부하를 줄이기 위해 일 배치(Daily Batch) 방식을 사용하며, 이로 인해 D-1(하루 전) 데이터가 최신 데이터가 됩니다.

작업 시점: 업무가 종료된 심야 시간 (예: 매일 자정 00:00).
작업 로직:
1. 1월 6일 하루 동안 쌓인 데이터를 마감.
2. 1월 7일 00:00에 기간계에서 데이터를 추출(Extract)하여 정보계로 적재(Load).
3. 1월 7일 아침에 사용자가 CDW에서 조회하는 데이터는 1월 6일자(D-1) 데이터임.
특징:
- 실시간성(Real-time)은 없으나, 대용량 데이터 분석 시 운영 시스템(기간계)에 부하를 주지 않음.
- CDW에는 D-1, D-2, D-3... 과거의 이력 데이터가 시계열로 축적됨.

ETL은 기간계(Legacy)의 데이터를 정보계(CDW)로 옮길 때 발생하는 '데이터 이사 과정'이자, SI에서 제품 비즈니스로 넘어갈 때 데이터 표준화가 실제로 구현되는 핵심 단계입니다.

4. ETL이란 무엇인가?

ETL은 데이터 웨어하우스(CDW) 구축 시 데이터를 수집, 가공, 적재하는 3단계 프로세스를 말합니다.

E (Extract, 추출):
- 어디서? 기간계(Legacy) 시스템의 DB에서.
- 무엇을? 어제 하루 동안 생성된(변경된) 데이터를 뽑아냅니다.
- 예: 1월 6일자 진료 기록 전체 조회.
T (Transform, 변환):
- 어떻게? 분석하기 좋은 형태로 데이터를 다듬고, 표준화합니다.
- 작업 내용: 날짜 포맷 통일(YYYYMMDD), 코드 매핑(남/녀 → M/F), 오탈자 정제, 주민번호 암호화 등.
- 핵심: '표준화 메타시스템'에 정의된 규칙이 바로 이 단계에서 적용됩니다.
L (Load, 적재):
- 어디로? 목적지인 정보계 시스템(ODS → CDW)으로.
- 결과: 데이터를 DB 테이블에 최종 저장합니다.

5. 전체 흐름도

SI 관점에서는 프로젝트마다 ETL을 새로 짰지만, 제품 비즈니스에서는 '표준화된 ETL 파이프라인'을 구축하여 어떤 병원의 데이터든 우리 제품(CDW) 규격에 맞게 자동으로 변환되어 들어오게 하는 것이 목표입니다.

단계	시스템	역할 및 데이터 상태	ETL의 역할
Source	기간계 (Legacy)	• 실시간 업무 처리 (진료, 수납) • 데이터 구조가 병원마다 다름	(E) 추출 대상 운영계 부하를 피하기 위해 심야 시간에 접근
↓	ETL 작업	(자정 00:00 ~ 새벽)	기간계 데이터를 퍼 올려서(E) → 그대로(ODS) 혹은 변환해서(T) → 옮김(L)
Target 1	ODS	• Raw Data (원천 그대로) • 기간계와 1:1로 복사된 데이터	1차 적재 (Load) 데이터 정합성 검증을 위한 임시 저장소
Target 2	정보계 / CDW	• Standardized Data (표준화됨) • 주제별(환자, 질병 등)로 통합된 데이터 • D-1 (어제 데이터)가 최신	2차 변환 및 적재 (Transform & Load) ODS 데이터를 분석용 모델에 맞춰 표준화하여 저장

[프로젝트] KCD-SNOMED CT 매핑 자동화 시스템 개발

strongyoung — Fri, 28 Nov 2025 13:15:26 +0900

1. 개요

1.1 필요성

현재 의료 SNOMED-CT매핑은 엑셀 기반 수작업, 임상의/정보팀의 반복 검토 필요
사람마다 기준이 달라 일관성 추적성 부족
OMOP CDM도입/고도화를 위해서는 진단코드의 빠르고 안정적인 standard concept 매핑이 필수
임상연구 등 후속 분석 파이프라인의 전제조건

1.2 목적

병원에서 사용하는 KCD/ICD 진단 코드 및 한글/영문 진단명을 SNOMED-CT 및 OMOP CDM 기준으로 자동 매핑하여 1) 수작업 매핑에 소요되는 시간과 인력 부담을 줄이고, 2) 매핑 일관성과 재현성을 확보하며, 3) CDM기반 연구 및 분석(코호트, AI모델링)을 효율적으로 지원

3. 시스템 목표 구조

3.1 전체 아키텍처

[CP] 제안서 작성 교육 - 제안 필승가이드 요약

strongyoung — Mon, 27 Oct 2025 14:19:07 +0900

제안필승가이드_요약_20251027.pdf

0.11MB

제안필승가이드_요약_20251027.hwp

0.11MB

제안필승가이드_20251027.pdf

0.11MB

[mini2] 흉부 X-Ray 영상 내 폐 영역 분할

strongyoung — Mon, 16 Jun 2025 11:32:47 +0900

영상 분할 (Image Segmentation)

영상을 픽셀 수준에서 분석하여 각 픽셀이 어떤 객체에 속하는지를 식별하는 기술
의미론적 분할(Semantic Segmentation): 모든 픽셀을 카테고리에 따라 부류
인스턴스 분할(Instance Segmentation): 같은 종류의 객체라도 개별 객체를 구분하여 각각 다른 라벨을 할당

U-Net

축소 경로: 일반적인 CNN의 형태를 따르며, 공간적 차운이 감소되고 영상 컨텍스트 정보가 압축된 특징 맵(feature map) 추출
확장 경로: 축소 경로에서 축소된 특징 맵을 점차적으로 확대하여 원래 이미지의 크기로 복원
스킵 연결(skip connections): 축소 경로의 특징 맵을 직접적으로 확장 경로의 해당 레이어와 병합하여, 경계와 같은 중요한 정보를 잘 유지하게 함

예시 1. CT 영상 내 다중 장기 분할(multi-organ segmentation) 기술

*Y. Wang et al, “Abdominal multi-organ segmentation with organ-attention networks and statistical fusion,” Medical Image Analysis, 2019.

예시 2. 안저 영상 내 혈관 영역 분할 기술

*J. Cao et al, “MFA-UNet: a vessel segmentation method based on multi-scale feature fusion and attention module,” Frontiers in Neuroscience, 2023.

실습) 흉부 X-ray 영상 내 폐 영역 분할 (U-Net 구조 설계 및 dice 계수 정의)

import os
import numpy as np
import matplotlib.pyplot as plt
from glob import glob
from tensorflow.keras.preprocessing.image import load_img, img_to_array
from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Conv2DTranspose, concatenate
from tensorflow.keras.optimizers import Adam
import tensorflow.keras.backend as K
from sklearn.model_selection import train_test_split


# 1) 데이터 로드
IMAGE_DIR = 'C:/Users/KDT_35/PycharmProjects/Oracle_Bio_Project/Mini2/Chest-X-Ray/image'
MASK_DIR = 'C:/Users/KDT_35/PycharmProjects/Oracle_Bio_Project/Mini2/Chest-X-Ray/mask'
image_paths = sorted(glob(os.path.join(IMAGE_DIR, '*.png')))
mask_paths = sorted(glob(os.path.join(MASK_DIR, '*.png')))

imgs = []
masks = []
for img_path, mask_path in zip(image_paths, mask_paths):
    img = img_to_array(load_img(img_path, color_mode='grayscale', target_size=(128,128))) / 255.0
    mask = img_to_array(load_img(mask_path, color_mode='grayscale', target_size=(128,128))) / 255.0
    imgs.append(img)
    masks.append(mask)

X = np.array(imgs)   # shape: (N,128,128,1)
y = np.array(masks)  # shape: (N,128,128,1)

# 2) Sample 데이터 시각화
fig, axes = plt.subplots(3, 2, figsize=(8, 12))
for i in range(3):
    axes[i,0].imshow(X[i].squeeze(), cmap='gray')
    axes[i,0].set_title('Chest X-ray')
    axes[i,0].axis('off')

    axes[i,1].imshow(y[i].squeeze(), cmap='gray')
    axes[i,1].set_title('Lung Mask')
    axes[i,1].axis('off')

plt.tight_layout()
plt.show()

# 3) train/validation 분할
X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, random_state=42, shuffle=True
)

# 4) U-Net 모델 정의
smooth = 1.0
def unet(input_size=(128,128,1)):
    inputs = Input(input_size)

    # Encoder
    c1 = Conv2D(64, 3, activation='relu', padding='same')(inputs)
    c1 = Conv2D(64, 3, activation='relu', padding='same')(c1)
    p1 = MaxPooling2D()(c1)

    c2 = Conv2D(128, 3, activation='relu', padding='same')(p1)
    c2 = Conv2D(128, 3, activation='relu', padding='same')(c2)
    p2 = MaxPooling2D()(c2)

    # Bottleneck
    c5 = Conv2D(512, 3, activation='relu', padding='same')(p2)
    c5 = Conv2D(512, 3, activation='relu', padding='same')(c5)

    # Decoder
    u6 = Conv2DTranspose(128, 2, strides=2, padding='same')(c5)
    m6 = concatenate([u6, c2])
    c6 = Conv2D(128, 3, activation='relu', padding='same')(m6)
    c6 = Conv2D(128, 3, activation='relu', padding='same')(c6)

    u7 = Conv2DTranspose(64, 2, strides=2, padding='same')(c6)
    m7 = concatenate([u7, c1])
    c7 = Conv2D(64, 3, activation='relu', padding='same')(m7)
    c7 = Conv2D(64, 3, activation='relu', padding='same')(c7)

    outputs = Conv2D(1, 1, activation='sigmoid')(c7)
    model = Model(inputs, outputs)
    return model

model = unet()

def dice_coef(y_true, y_pred):
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    intersection = K.sum(y_true_f * y_pred_f)
    return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)

model.compile(optimizer=Adam(1e-4), loss='binary_crossentropy', metrics=[dice_coef])

# 5) 모델 학습
history = model.fit(
    X_train, y_train,
    validation_data=(X_val, y_val),
    batch_size=8,
    epochs=20,
    shuffle=True
)

# 6) 학습 결과 시각화
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Val Loss')
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Binary Crossentropy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['dice_coef'], label='Train Dice')
plt.plot(history.history['val_dice_coef'], label='Val Dice')
plt.title('Dice Coefficient')
plt.xlabel('Epoch')
plt.ylabel('Dice Score')
plt.legend()

plt.tight_layout()
plt.show()

# 7) 예측 결과 시각화
import random

num_samples = 5
indices = random.sample(range(len(X_val)), num_samples)
preds = model.predict(X_val[indices])

fig, axes = plt.subplots(num_samples, 3, figsize=(12, 3 * num_samples))
for i, idx in enumerate(indices):
    axes[i,0].imshow(X_val[idx].squeeze(), cmap='gray')
    axes[i,0].set_title('Input')
    axes[i,0].axis('off')

    axes[i,1].imshow(y_val[idx].squeeze(), cmap='gray')
    axes[i,1].set_title('Ground Truth')
    axes[i,1].axis('off')

    axes[i,2].imshow(preds[i].squeeze(), cmap='gray')
    axes[i,2].set_title('Prediction')
    axes[i,2].axis('off')

plt.tight_layout()
plt.show()

오라클 클라우드 기반 의료바이오 서비스 개발 성취도 평가

strongyoung — Wed, 4 Jun 2025 17:16:20 +0900

[문항1] 순환 신경망(RNN)의 주요 특징으로 옳은 것을 고르시오.

1) 입력 데이터 간 독립성이 강조된다.

2) 시간에 따른 순차적 데이터 처리가 가능하다.

3) 뉴런의 활성화가 고정되어 있다.

4) 데이터를 병렬적으로만 처리한다.

5) 공간적 데이터를 주로 처리한다.

[문항2] 다음 중 워드 임베딩(Word Embedding)의 설명으로 가장 적절한 것은?

1) 문장 구조를 기준으로 문서 전체를 벡터화하는 기술이다.

2) 단어를 숫자 형태의 벡터로 표현하여 단어 간 의미적 관계를 나타내는 기술이다.

3) 단어를 이진 숫자로 변환하여 저장하는 기술이다.

4) 문장을 음성으로 변환하는 기술이다.

5) 문장 간의 유사성만을 평가하는 기술이다.

[문항3] 트랜스포머(Transformer) 모델에 대한 설명으로 가장 적절한 것은?

1) 입력 문장을 순차적으로 처리하여 학습 속도가 느리다.

2) 자가 어텐션(Self-attention) 기법을 사용하여 문장의 맥락을 효과적으로 이해한다.

3) 오직 양방향으로만 정보를 처리한다.

4) 위치 정보를 전혀 사용하지 않는다.

5) RNN과 같이 순환 구조를 가진다.

[문항4] 다음 중 트랜스포머 모델의 위치 정보 인코딩(Positional Encoding)에 관한 설명으로 옳은 것은?

1) 입력 단어의 중요도만 계산한다.

2) RNN처럼 순차적으로 처리한다.

3) 단어의 순서를 이해하기 위해 문장 내 단어의 위치 정보를 추가한다.

4) 자가 어텐션을 수행하는 데 불필요한 요소이다.

5) 주로 이미지 데이터 처리에만 사용된다.

[문항5] GPT 모델이 사용하는 자가회귀(auto-regressive) 방식에 대한 설명으로 옳은 것은?

1) 양방향으로 주변 단어를 모두 참고하여 다음 단어를 예측한다.

2) 이전 단어만을 참고하여 다음 단어를 순차적으로 예측한다.

3) 단어의 순서와 무관하게 랜덤으로 단어를 예측한다.

4) 입력 데이터의 의미보다는 형태를 주로 분석한다.

5) 주로 음성 데이터를 처리할 때 사용된다.

[문항6] 프롬프트 엔지니어링에서 중요한 요소로 보기 어려운 것은?

1) 지시사항(instruction)

2) 참고 데이터(context)

3) 출력 양식(output format)

4) 사용자 입력 데이터(user input)

5) 사용자 개인 정보

[문항7] 규칙 기반 챗봇과 AI 기반 챗봇의 차이에 대한 설명으로 가장 적절한 것은?

1) 규칙 기반 챗봇은 사용자의 자유로운 질문에 자연어 처리를 통해 응답한다.

2) AI 기반 챗봇은 미리 정의된 선택지를 통해 사용자가 질문을 선택하도록 한다.

3) 규칙 기반 챗봇은 제한된 답변을 사전 설정된 방식으로 제공한다.

4) AI 기반 챗봇은 대화 흐름이 예측 가능하며 고정적이다.

5) 두 챗봇 모두 대화의 흐름이 유동적으로 변화한다.

[문항8] GPT 모델의 파라미터 중, 응답의 창의성을 조절하는 역할을 하는 것은 무엇인가?

1) Maximum Tokens

2) Stop Sequences

3) Temperature

4) Frequency Penalty

5) Presence Penalty

[문항9] GPT 기반 인터랙티브 서비스 중, 시각적 데이터를 처리하기 위한 방법으로 가장 적절한 것은?

1) 시각 데이터를 텍스트로 변환하지 않고 직접 처리한다.

2) 시각 데이터를 base64 인코딩을 통해 텍스트로 변환하여 사용한다.

3) 시각 데이터는 GPT에서 처리할 수 없으므로 별도의 모델이 필요하다.

4) 시각 데이터는 오직 외부 서비스로만 처리할 수 있다.

5) 시각 데이터는 GPT의 프롬프트에서 완전히 배제된다.

[문항10] LangChain 프레임워크의 핵심 요소 중 모듈형 구성 요소를 재사용 가능한 파이프라인으로 조립하는 개념은 무엇인가?

1) 에이전트 (Agent)

2) 체인 (Chain)

3) 메모리 (Memory)

4) 도구 (Tool)

5) 데이터베이스 (Database)

[고급 프롬프트 공학] 퓨 샷 학습, Chain of Thought, 자기일관성, Tree of Thoughts

strongyoung — Wed, 4 Jun 2025 12:05:32 +0900

학습 목표

1. 제로 샷의 개념을 이해하고 이를 활용하여 응답 정확도를 향상시킬 수 있다.

2. Chain of Thought를 활용하여 복잡한 추론 과정을 명시적으로 생성할 수 있다.

3. 자기일관성의 작동 메커니즘을 설명하고, 이를 통해 최적의 답을 선택할 수 있다.

4. Tree of Thought의 구조를 이해하고 적용하여 문제 해결 성능을 개선할 수 있다.

5. 고급 프롬프트 공학 기법을 구현하고, 실제 문제 해결에 적용할 수 있다.

프롬프트 공학

자연어 처리 시스템에서 원하는 출력 결과를 얻기 위해 입력 프롬프트를 설계하고 최적화하는 기술
AI 모델의 성능을 극대화하고 사용자가 의도한 결과를 정확하게 도출하는 데 중요

1. 제로 샷(zero-shot) 프롬프트

어떠한 데모나 예제를 제공하지 않고 과업 지침을 직접 LLM에게 전달

## 고급 프롬프트 공학
# 제로 샷 (zero-shot) 프롬프트
# - 어떤 데모나 예제를 제공하지 않고 과업 지침을 직접 LLM에게 전달

import os  # 운영체제 관련 기능을 다루기 위한 모듈 ( 환경변수 설정 등에 사용 )
from langchain_core.prompts import PromptTemplate  # 프롬프트 템플릿을 만들기 위한 클래스
from langchain_openai import ChatOpenAI      # OpenAI의 GPT모델을 래핑한 LangChain객체

# 환경변수에 OpenAI API 키 설정
# os.environ["OPENAI_API_KEY"] = "p2V54A"

# 직접 API키를 변수로 저장(API키를 직접 문자열로 저장)
api_key = "sJdfsaA"

# GPT 모델 설정
# gpt-4-turbo 사용, API키를 직접 인자로 전달
model = ChatOpenAI(model="gpt-4-turbo", api_key=api_key)

# 입력 텍스트의 감정을 분류하는 프롬프트 템플릿 정의
prompt = PromptTemplate(
    input_variables=["text"],
    template="""Classify the sentiment of this text: {text}.
    Provide only the sentiment classfication as 'positive', 'negative', or 'neutral'."""
)

# 프롬프트와 모델을 결합하여 체인 구성
chain = prompt | model

# 예시 텍스트를 이용해 체인 실행
result = chain.invoke({"text": "I hated that movie, it was terrible!"})
print(result.content.strip())

2. 퓨 샷(few-shot) 학습

명시적인 지침 없이 작업과 관련된 몇가지 입력-출력 예제만을 LLM에게 제공
답변 품질과 정확도를 크게 개선 가능

## 퓨샷 (few-shot) 학습
# - 명시적인 지침 없이 작업과 관련된 몇가지 입력-출력 예제만을 LLM에게 제공
# - 답변 품질과 정확도를 크게 개선 가능

# 1. GPT 모델 설정 및 예시 데이터 입력
import os  # 운영체제 관련 기능을 다루기 위한 모듈 ( 환경변수 설정 등에 사용 )
from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate  # 프롬프트 템플릿을 만들기 위한 클래스
from langchain_openai import ChatOpenAI      # OpenAI의 GPT모델을 래핑한 LangChain객체

# 환경변수에 OpenAI API 키 설정
os.environ["OPENAI_API_KEY"] = "sk-pro"
# GPT 모델 설정
model = ChatOpenAI(model="gpt-4-turbo")

# 예시 데이터에 사용할 개별 프롬프트 템플릿 정의
example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Text: {input}\nSentiment: {output}"
)

# Few-shot 학습에 사용할 예시 데이터
examples = [
    {"input": "I absolutely love the new update! Everything works seamlessly.", "output": "posirive"},
    {"input": "It's okay, but I think it could use more features.", "output": "neutral"},
    {"input": "I'm disappointed with the service, I expected much better performance.", "output": "negative"}
]

# FewShotPromptTemplate 설정, 프롬프트 템플릿 정의
# {text} 자리에 사용자가 입력한 문장이 들어감
# 감정 분석을 수행하라는 명령과, 출력 형식도 명확히 지정함
prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    suffix="""Classify the sentiment of this text: {text}.
    Provide only the sentiment classification as 'positive', 'negative', or 'neutral'.""",
    input_variables=["text"]
)

# 프롬프트와 모델을 파이프(|) 연산자를 사용해 결합
# 프롬프트와 모델을 결합하여 체인 구성
chain = prompt | model

# 예시 텍스트를 이용해 체인 실행
# 입력은 딕셔너리 형태로 전달: {"text": "..."}
result = chain.invoke({"text": "I hated that movie, it was terrible!"})
print(result.content.strip())  # 모델 출력에서 공백을 제거하고 감정 결과만 출력

3. Chain of Thought (CoT) 프롬프트

중간 추론 단계를 포함한 응답을 접두사로 추가하여 모델이 추론할 수 있는 능력 부여

## Chain of Thought(CoT) 프롬프트
# 1. GPT 모델 및 CoT 지시문 설정

import os
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

# 환경변수에 OpenAI 키 설정
os.environ["OPENAI_API_KEY"] = "sk-pro"

# GPT 모델 설정
model = ChatOpenAI(model="gpt-4-turbo")

# Chain of Thought 지시문 설정
cot_instruction = "Let's think step by step!"

# Chain of Thought 방식의 질문 템플릿 생성
reasoning_prompt = "{question}\n" + cot_instruction
prompt = PromptTemplate(
    template=reasoning_prompt,
    input_variables=["question"]
)

# 2. 체인 구성 및 실행
# 프롬프트와 모델을 결합한 체인 구성
chain = prompt | model

# 체인을 실행하여 문제 풀이 결과 출력
result = chain.invoke({
    "question": """There were 5 apples originally. I ate 2 apples.
    My friend gave me 3 apples. How many apples do I have now?"""
})
print(result.content.strip())

4. 자기 일관성 (Self-consistency)

질문에 대해 여러 후보 답변을 생성한 후, 가장 일관된 또는 가장 빈번한 답변을 최종 출력으로 선택

## 자기 일관성 (Self-consistency)
# 1. 라이브러리 설정 & 여러 솔루션을 생성하는 첫번째 체인 구성
import os  # 운영체제 관련 기능을 다루기 위한 모듈 ( 환경변수 설정 등에 사용 )
from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate  # 프롬프트 템플릿을 만들기 위한 클래스
from langchain_openai import ChatOpenAI      # OpenAI의 GPT모델을 래핑한 LangChain객체
from langchain_core.output_parsers import StrOutputParser

# 환경변수에 OpenAI API 키 설정
os.environ["OPENAI_API_KEY"] = ""

# GPT 모델 설정
model = ChatOpenAI(model="gpt-4-turbo")

# 첫번째 체인: 여러 솔루션 생성 프롬프트
solutions_template = """
Generate {num_solutions} distinct answers to this question:
{question}

Solutions:
"""

solutions_prompt = PromptTemplate(
    template=solutions_template,
    input_variables=["question", "num_solutions"]  # question, num_solutions 라는 2개의 입력변수를 사용
)

solutions_chain = solutions_prompt | model | StrOutputParser()


# 2. 여러 솔루션 중 다수 결과를 채택하는 두 번째 체인 구성
# 두 번째 체인: 솔루션의 일관성 확인 프롬프트
consistency_template = """
For each answer in the solutions below, count how many times it occurs. Finally, choose the answer that occurs most.

Solutions:
{solutions}

Most frequent solution:
"""
consistency_prompt = PromptTemplate(
    template=consistency_template,
    input_variables=["solutions"]
)
consistency_chain = consistency_prompt | model | StrOutputParser()

# 두 체인을 RunnableSequence 로 직접 연결하여 순차적으로 실행하고 중간 결과 출력
solutions = solutions_chain.invoke({
    "question": "Which year was the Declaration of Independence of the United States signed?",
    "num_solutions": "5"
})
print("Generated solutions:")
print(solutions.strip())

final_result = consistency_chain.invoke({"solutions": solutions})

print("\nMost frequent solution")
print(final_result.strip())

5. Tree of Thoughts (ToT) 프롬프트

문제를 해결하기 위해 다양한 사고 경로(branch)를 탐색

import os  # 운영체제 관련 기능을 다루기 위한 모듈 ( 환경변수 설정 등에 사용 )
from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate  # 프롬프트 템플릿을 만들기 위한 클래스
from langchain_openai import ChatOpenAI      # OpenAI의 GPT모델을 래핑한 LangChain객체
from langchain_core.output_parsers import StrOutputParser

from chain_of_thought_0604 import reasoning_prompt

# 환경변수에 OpenAI API 키 설정
os.environ["OPENAI_API_KEY"] = "A"

# GPT 모델 설정
model = ChatOpenAI(model="gpt-4-turbo")

# 2. 솔루션 생성 프롬프트 설정
solutions_prompt = PromptTemplate(
    template="""
    Generate {num_solutions} distinct solutions for the problem: {problem}.
    Consider factors like: {factors}
    
    Solutions:
    """,
    input_variables=["problem", "factors", "num_solutions"]
)

# 솔루션 평가 프롬프트 설정
evaluation_prompt = PromptTemplate(
    template="""
    Evaluate each solution below by analyzing pros, cons, feasibility, and probability of success.
    
    Solutions:
    {solutions}
    
    Evaluations:
    """,
    input_variables=["solutions"]
)

# 3. 심층적 추론 및 솔루션 순위화 프롬프트 설정
# 심층적 추론 프롬프트 설정
reasoning_prompt = PromptTemplate(
    template="""
    For the most promising solutions below, explain scenarios, implementation starategies, partnerships needed, and potential obstacles.
    
    Evaluations:
    {evaluations}
    
    Enhanced Reasoning:
    """,
    input_variables=["evaluations"]
)

# 솔루션 순위화 프롬프트 설정
ranking_prompt = PromptTemplate(
    template="""
    Rank the solutions below from most to least promising based on evaluations and enhanced reasoning.
    
    Enhanced Reasoning:
    {enhanced_reasoning}
    
    Ranked Solutions:
    """,
    input_variables=["enhanced_reasoning"]
)

# 4. 체인 구축 및 실행
# 각 단계 결과 명시적으로 전달하는 함수 설정
def chain_executor(problem, factors, num_solutions):
    solutions = (solutions_prompt | model | StrOutputParser()).invoke({
        "problem": problem,
        "factors": factors,
        "num_solutions": num_solutions
    })

    evaluations = (evaluation_prompt | model | StrOutputParser()).invoke({"solutions": solutions})
    enhanced_reasoning = (reasoning_prompt | model | StrOutputParser()).invoke({"evaluations": evaluations})
    ranked_solutions = (ranking_prompt | model | StrOutputParser()).invoke({"enhanced_reasoning": enhanced_reasoning})

    return ranked_solutions

# 체인 실행 및 결과 출력
result = chain_executor(
    problem="Prompt engineering",
    factors="Requirements for high task performance, low token use, and few calls to the LLM",
    num_solutions="3"
)

print(result.strip())

RAG기반 LLM 서비스 구현 - Streamlit 기반 웹서비스 구현

strongyoung — Mon, 2 Jun 2025 16:31:22 +0900

검색 증강 생성(Retrieval Augmented Generation)

대규모 언어 모델(LLM)의 출력을 향상시키기 위해 외부 지식 베이스를 참조하는 기술

실습 1. PDF 요약 서비스

설치: pip install streamlit PyPDF2 langchain langchain-openai langchain-community openai faiss-cpu

# 검색 증강 생성
# 실습 1. PDF 요약 서비스
import os
import streamlit as st
from PyPDF2 import PdfReader
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains.question_answering import load_qa_chain
from langchain_community.callbacks.manager import get_openai_callback  # 최신 버전 호환

# OpenAI API 키 설정
os.environ["OPENAI_API_KEY"] = "apikey"

# 텍스트를 분할하여 임베딩 후 FAISS 벡터 DB 생성
def process_text(text):
    text_splitter = CharacterTextSplitter(
        separator="\n",
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len
    )
    chunks = text_splitter.split_text(text)
    embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")
    documents = FAISS.from_texts(chunks, embeddings)
    return documents


# Streamlit 메인 애플리케이션
def main():
    st.title("GPT-4 기반 PDF 요약기")
    st.divider()

    # PDF 파일 업로드
    pdf = st.file_uploader('PDF 파일을 업로드 하세요.', type='pdf')

    if pdf:
        # PDF 텍스트 추출
        pdf_reader = PdfReader(pdf)
        text = ""
        for page in pdf_reader.pages:
            text += page.extract_text()

        # 텍스트 처리 후 벡터 DB 생성
        documents = process_text(text)

        # 요약 쿼리
        query = "업로드 된 PDF 파일의 내용을 약 3~5 문장으로 요약해 주세요."

        if query:
            # 벡터 유사도 기반 문서 검색
            docs = documents.similarity_search(query, k=3)

            # GPT-4 모델로 질의응답 체인 설정
            llm = ChatOpenAI(model="gpt-4", temperature=0.1)
            chain = load_qa_chain(llm, chain_type='stuff')

            # 요약 생성 및 API 사용 비용 출력
            with get_openai_callback() as cost:
                response = chain.run(input_documents=docs, question=query)
                print(cost)

            st.subheader("요약 결과:")
            st.write(response)


# 애플리케이션 수행
if __name__ == '__main__':
    main()

# 터미널에 'streamlit run summary.py'

실습 2. PDF 질의응답 서비스

설치: pip install streamlit PyPDF2 langchain langchain-openai langchain-community openai faiss-cpu

## PDF 질의응답 서비스
# 2. Streamlit 기반 웹 서비스 구현
import os
import streamlit as st
from PyPDF2 import PdfReader
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains.question_answering import load_qa_chain

# OpenAI API 키 설정
os.environ["OPENAI_API_KEY"] = "apikey"

# Streamlit 제목 설정
st.title("PDF 기반 GPT-4 질의응답")

# PDF 파일 업로드
pdf = st.file_uploader('PDF 파일을 업로드 하세요.', type='pdf')

if pdf:
    # PDF 텍스트 추출
    pdf_reader = PdfReader(pdf)
    text = ""
    for page in pdf_reader.pages:
        text += page.extract_text()

    # 텍스트를 작은 단위(chunk)로 분할
    splitter = CharacterTextSplitter(
        separator="\n",
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len
    )
    chunks = splitter.split_text(text)

    # 임베딩을 이용한 벡터 저장소 생성
    embeddings = OpenAIEmbeddings()
    vector_store = FAISS.from_texts(chunks, embeddings)

    # 사용자 질의 입력
    query = st.text_input("PDF 내용에 대해 질문하세요:")

    if query:
        # 유사도 겁색으로 관련 chunk 추출
        docs = vector_store.similarity_search(query, k=3)

        # GPT-4 모델로 질의응답 체인 설정
        llm = ChatOpenAI(model_name="gpt-4", temperature=0)
        qa_chain = load_qa_chain(llm, chain_type='stuff')

        # 질의에 대한 답변 생성
        response = qa_chain.run(input_documents=docs, question=query)

        # 결과 표시
        st.subheader("답변 결과")
        st.write(response)

# 실행 'streamlit run qna.py'

실습 3. PDF 기반 대화형 서비스

설치: pip install streamlit streamlit-chat langchain langchain-openai langchain-community openai PyPDF2 faiss-cpu

## 실습 3. PDF기반 대화형 서비스

# 필수 라이브러리 불러오기
import os
import tempfile  # 임시 파일 생성용
import streamlit as st  # Streamlit 웹 앱 구성용
from streamlit_chat import message  # 사용자-챗봇 채팅 메시지 형식
from langchain_openai import OpenAIEmbeddings, ChatOpenAI  # OpenAI 임베딩, 채팅 모델
from langchain.chains import ConversationalRetrievalChain  # 문서 기반 QA 체인
from langchain_community.vectorstores import FAISS  # 벡터 저장소로 FAISS 사용
from langchain_community.document_loaders import PyPDFLoader  # PDF 문서 로더

# OpenAI API 키 설정 (보안상 .env 파일로 관리하는 것이 바람직)
os.environ["OPENAI_API_KEY"] = "sk-..."  # ✳️ 현재는 노출 상태 → 위험

# 사이드바에서 PDF 파일 업로드 UI 구성
uploaded_file = st.sidebar.file_uploader("PDF 파일을 업로드하세요.", type="pdf")

# 파일이 업로드되었을 때만 실행
if uploaded_file:
    # 업로드된 PDF를 임시 파일로 저장
    with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
        tmp_file.write(uploaded_file.getvalue())  # 파일 내용 저장
        tmp_file_path = tmp_file.name  # 경로 저장

    # PDF 문서를 LangChain용으로 로드
    loader = PyPDFLoader(tmp_file_path)
    data = loader.load()  # PDF 전체 내용을 로드

    # 문서 내용을 임베딩하여 벡터화
    embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")  # 임베딩 모델 선택
    vectors = FAISS.from_documents(data, embeddings)  # 문서들을 FAISS 벡터DB에 저장

    # 대화형 질의응답 체인 구성 (GPT-4 사용)
    chain = ConversationalRetrievalChain.from_llm(
        llm=ChatOpenAI(temperature=0.0, model_name='gpt-4'),  # GPT-4 모델 지정
        retriever=vectors.as_retriever()  # 검색기 역할을 FAISS로 연결
    )

# 사용자 질문을 처리하는 함수 정의
def conversational_chat(query):
    result = chain({  # 사용자 질문과 이전 대화 히스토리를 넘김
        "question": query,
        "chat_history": st.session_state['history']
    })
    # 세션에 질문/답변 저장
    st.session_state['history'].append((query, result["answer"]))
    return result["answer"]  # 챗봇의 응답 반환

# 세션 상태 초기화 (초기 실행 시 한 번만 실행됨)
if 'history' not in st.session_state:
    st.session_state['history'] = []  # 대화 히스토리 저장용

if 'generated' not in st.session_state:
    # 업로드된 파일이 있을 때만 초기 질문 메시지 설정
    st.session_state['generated'] = [f"{uploaded_file.name}에 관한 질문을주세요."]

if 'past' not in st.session_state:
    st.session_state['past'] = ["반응하세요!"]  # 사용자 질문 기록용

# Streamlit의 대화 UI 영역 설정
response_container = st.container()  # 챗봇 응답 출력 영역
container = st.container()  # 입력 영역

# 입력 폼 UI 구성
with container:
    with st.form(key='Conv_Question', clear_on_submit=True):
        user_input = st.text_input(  # 질문 입력창
            "Query:",
            placeholder="PDF 파일에 대해 질문해보세요. :)",
            key='input'
        )
        submit_button = st.form_submit_button(label='Send')  # 제출 버튼

    # 버튼 클릭 + 입력이 존재할 경우 처리
    if submit_button and user_input:
        output = conversational_chat(user_input)  # 질문을 LLM에 전달
        st.session_state['past'].append(user_input)  # 사용자 질문 저장
        st.session_state['generated'].append(output)  # 챗봇 응답 저장

# 이전 대화 내역 시각화 (채팅 UI 형식)
if st.session_state['generated']:
    with response_container:
        for i in range(len(st.session_state['generated'])):
            message(
                st.session_state["past"][i], is_user=True,
                key=f'{i}_user', avatar_style="fun-emoji", seed="Nala"
            )  # 사용자 메시지 표시
            message(
                st.session_state["generated"][i], key=str(i),
                avatar_style="bottts", seed="Fluffy"
            )  # 챗봇 응답 표시

# 참고 실행 방법 (터미널에서 실행)
# streamlit run chatbot.py

실습 4. CSV 파일 분석 서비스

설치: pip install streamlit pandas langchain langchain-openai langchain-experimental openai

import os
import pandas as pd
import streamlit as st
from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
from langchain_openai import ChatOpenAI
from langchain.agents import AgentType

os.environ["OPENAI_API_KEY"] = "sk-"

# Streamlit 웹 제목 설정
st.title("CSV 데이터 분석 웹 서비스")

# CSV 파일 업로드
uploaded_file = st.file_uploader("CSV 파일을 업로드하세요.", type="csv")

if uploaded_file:
    # CSV 파일을 데이터프레임으로 읽기
    df = pd.read_csv(uploaded_file)
    st.write("### 업로드된 데이터 미리보기:")
    st.dataframe(df.head())

    # LangChain 데이터프레임용 분석 에이전트 생성
    agent = create_pandas_dataframe_agent(
        ChatOpenAI(temperature=0, model='gpt-4o'),
        df,
        verbose=False,
        agent_type=AgentType.OPENAI_FUNCTIONS,
        allow_dangerous_code=True
    )

    # 사용자 데이터 분석 질문 입력
    st.write("### 데이터 분석 질문 입력")
    user_query = st.text_input("질문 입력", placeholder="질문을 입력하세요.")

    # 분석 수행 및 결과 출력
    if st.button("분석 시작"):
        if user_query:
            with st.spinner("분석 중..."):
                result = agent.run(user_query)
                st.write("### 분석 결과:")
                st.write(result)

# 실행: 'streamlit run csv_reader.py'

PACS를 활용한 의료영상 분석 성취도 평가

strongyoung — Thu, 29 May 2025 10:43:57 +0900

[문항1] PACS 시스템의 주요 목적에 대한 설명으로 가장 적절한 것은?

1) 환자에게 직접 진단 결과를 설명하기 위한 시스템이다.

2) 다양한 의료 영상 데이터를 저장하고 관리하기 위한 시스템이다.

3) 의사가 처방전을 작성하기 위한 시스템이다.

4) 환자의 예약 정보를 관리하는 병원 접수 시스템이다.

5) 병원의 재정적 업무를 처리하기 위한 회계 시스템이다.

[문항2] 다음 중 DICOM의 설명으로 올바르지 않은 것은?

1) 의료 영상 데이터의 저장 및 교환을 위한 국제 표준이다.

2) 영상 데이터와 메타데이터를 함께 저장한다.

3) 서로 다른 의료 장비 간의 호환성을 제공한다.

4) 환자 정보를 보호하기 위한 보안 기능을 지원한다.

5) 문서 작성 및 편집에 사용되는 일반적인 파일 형식이다.

[문항3] CT 촬영이 생성하는 영상으로 가장 적절한 것은?

1) 신체의 3차원 입체 영상

2) 피부 표면 영상

3) 신체 내부의 소리

4) 피부 온도 영상

5) 근육의 움직임 영상

[문항4] 다음 중 단일 퍼셉트론이 구현할 수 없는 논리 게이트를 고르시오.

1) AND 게이트

2) OR 게이트

3) NAND 게이트

4) XOR 게이트

5) NOT 게이트

[문항5] 다층 퍼셉트론(MLP)의 구조에 포함되지 않는 층을 고르시오.

1) 입력층

2) 출력층

3) 은닉층

4) 저장층

5) 위의 보기 모두 포함된다.

[문항6] 심층 신경망(Deep Neural Network)이 기존의 얕은 신경망과 다른 점을 고르시오.

1) 입력층이 존재하지 않는다.

2) 가중치를 사용하지 않는다.

3) 은닉층의 개수가 더 많다.

4) 출력층이 더 많다.

5) 편향(bias)을 사용하지 않는다.

[문항7] 드롭아웃(Dropout)의 설명으로 가장 적절한 것을 고르시오.

1) 신경망의 층을 늘리는 방법이다.

2) 데이터를 추가로 만들어 학습을 늘리는 방법이다.

3) 일부 뉴런을 랜덤하게 제외하여 과적합을 방지하는 방법이다.

4) 가중치의 크기를 고정하는 방법이다.

5) 손실 함수의 값을 늘려 학습 속도를 높이는 방법이다.

[문항8] 다음 중 심층 신경망의 기본 구성 요소가 아닌 것을 고르시오.

1) 밀집층(Dense Layer)

2) 활성화 함수(Activation Function)

3) 손실 함수(Loss Function)

4) 저장층(Storage Layer)

5) 출력층(Output Layer)

[문항9] 최적화(Optimization) 과정에서 손실 함수를 최소화하는 방법으로, 기울기를 이용하여 점차적으로 가중치를 조정하는 기법을 고르시오.

1) 랜덤 초기화(Random Initialization)

2) 드롭아웃(Dropout)

3) 경사 하강법(Gradient Descent)

4) 데이터 증강(Data Augmentation)

5) 배치 정규화(Batch Normalization)

[문항10] 합성곱 신경망에서 입력 이미지에 필터(커널)를 적용하여 특징을 추출하는 연산을 무엇이라 하는지 고르시오.

1) 활성화 연산(Activation Operation)

2) 풀링 연산(Pooling Operation)

3) 합성곱 연산(Convolution Operation)

4) 평탄화 연산(Flatten Operation)

5) 정규화 연산(Normalization Operation)

오라클 DB를 활용한 판독문 데이터 분석 성취도 평가

strongyoung — Wed, 21 May 2025 15:51:36 +0900

[문항1] 다음 중 비정형 텍스트 분석을 통해 분석이 가능한 자료는?

1) 인구통계학 데이터

2) 임상수치 데이터

3) 판독문 데이터

4) CT 데이터

5) MRI 데이터

[문항2] 다음 중 자연어 처리의 개념으로 적절하지 않은 것은?

1) 자연어는 사람이 일상적으로 사용하는 언어이다

2) 자연어 처리는 사람의 언어를 컴퓨터가 이해할 수 있도록 만드는 기술이다.

3) 자연어 처리는 통계학, 인공지능이 중요하며 언어학의 개념은 필요 없다.

4) 구조화된 숫자나 코드보다 문장형 텍스트가 훨씬 풍부한 정보를 담고 있다.

5) 비정형 텍스트 데이터의 핸들링을 위해 자연어 처리를 필요로 한다.

[문항3] 다음 중 자연어 처리에 대한 의료 분야 예시로 옳지 않은 것은?

1) 판독문 분석

2) 약제 물류 분석

3) 진료기록 자동 요약

4) 진단 및 처방 추출

5) 환자 상담 챗봇

[문항4] 다음 중 자연어 처리의 단계와 그 설명이 적절하게 연결되지 않은 것은?

1) 토큰화 : 문장을 단어/어절 단위로 분리

2) 정제 : 특수기호, 공백 등 제거

3) 정규화 : 동일의미 표현 통일

4) 불용어 제거 : 분석에 필요없는 단어 제거

5) 형태소 분석 : 토큰을 묶어 문장단위로 분석

[문항5] python의 konlpy 패키지를 사용하기 위해 설치했던 프로그램으로 가장 적절한 것은?

1) JAVA

2) SPSS

3) SAS

4) S

5) VScode

[문항6] 아래 설명에 가장 부합하는 것은 무엇인가? 텍스트를 숫자 벡터로 바꾸는 방법 중 하나로, 단어의 등장 빈도를 고려하면서도 문서전체에서 얼마나 희귀한 단어인지를 함께 반영한다. 흔하게 등장하는 단어는 가중치를 낮추고, 특정 문서에서만 등장하는 단어는 높게 평가하는 방법이다.

1) Regression

2) Logistic Regression

3) PCA

4) TF-IDF

5) Confusion Matrix

[문항7] 다음 중 워드 임베딩에 대한 설명으로 적절하지 않은 것은?

1) 자연어를 수치 벡터로 변환하는 대표적인 기법이다.

2) 각 단어를 고정된 차원의 숫자 벡터로 맵핑한다.

3) 단어 간 의미적 유사성이 벡터 공간의 거리로 표현된다.

4) 반의어는 벡터 위치가 가깝게 위치한다.

5) 다른 단어와의 관계의 의미까지 담은 전환 방식이다.

[문항8] 다음 중 정규표현식에 대한 설명으로 적절하지 않은 것은?

1) 문자열의 규칙을 표현하기 위한 특수한 문법 체계이다.

2) 단어, 숫자, 공백, 기호, 반복 등의 규칙을 기호화 된 문법으로 기술한다.

3) 텍스트 자체를

4) 문자열이 어떤 모양인지를 설명하는 문장이다.

5) 찾고자 하는 형식을 특수한 규칙 문자열로 규정할 수는 없다.

[문항9] Word2Vec을 통해 구한 단어 유사도 점수에 대한 설명으로 적절하지 않은 것은?

1) 토큰을 기준으로 의미상 유사한 정도를 점수로 매긴 척도이다.

2) -1부터 1까지의 값을 가진다.

3) 1에 가까울수록 의미적으로 유사하다.

4) 0에 가까울수록 의미적으로 반대이다.

5) 단어의 유사도는 측정 매체, 측정 시점에 따라 변할 수 있다.

[문항10] 다음 중 Word2Vec을 이용한 예측 모델에 대한 설명으로 적절하지 않은 것은?

1) 항생제와 그에 따른 반응을 통해 감염균을 예측하는 모형을 수립할 수 있다.

2) 감염균 레이블을 독립변수로, 생성된 벡터들을 종속변수로 두고 모델을 수립한다.

3) Random Forest를 통해 트리 기반 앙상블 모델을 수립할 수 있다.

4) Logistic Regression은 선형 기반 분류기로, 클래스 수가 많은 경우 성능이 떨어진다.

5) MLP의 경우 성능의 향상을 위한 방법 중 하나로 정규화가 고려될 수 있다.