jju71 님의 블로그

MalConv2_GCG

jju71 — Mon, 21 Sep 2026 22:00:43 +0900

malconv2.pdf

0.96MB

Malconv GCG

정의: 기존 Malconv에 어텐션에서 영감을 얻어 새로운 게이팅 방법인 전역 채널 게이팅(GCG)를 적용한 악성코드 분류 탐지 모델

장점

전체 문맥 파악: 기존 Malconv에 없던 전체 입력 공간에 걸친 특징 간 상호작용 학습으로 기존 방식 개선
전체 파일 처리: 고정 메모리 기법으로 적용해 기존 2MB 길이 제한을 없애며 자르지 않고 파일 전체를 처리함
메모리 효율성: 기존 GPU메모리 128GB 이상 필요했던 문제를 2.2 GB로 줄임
학습시간: 1 epoch당 약 21시간 29분을 4시간 5분으로 줄임

단점

계산 비용 증가: 전역 채널 게이팅을 통해 더 많은 연산을 수행한다. 메모리 효율은 그대로지만 계산량이 커져 학습 속도가 느려짐
메모리 사용량 증가: 고정 메모리 기법을 적용한 Malconv와 비교하면 1.1GB에서 2.2GB로 증가함
학습 시간 증가: 기존 Malconv보다 줄이긴 했지만 고정 메모리 기법보다는 길어짐

Malconv GCG구조

입력: 실행 파일의 바이트열을 입력으로 사용함

Context(파일 전체에서 얻은 정보)

Embed: 바이트 하나당 숫자 8개로 이루어진 벡터로 표현함. 즉, 각 바이트 위치의 값을 8차원으로 만듦. 파일이 끝나면(EOF) 특수 토큰을 사용해 임베딩 레이어에서 모든 값이 0인 벡터로 매핑되도록 설계되어 있다.
nn.Embedding(num_embeddings=257, embedding_dim=8)

1D Conv: 합성곱 연산 수행으로 특징을 추출한다.
a = nn.Conv1d(8, 256, kernel_size=256, stride=64)
b = nn.Conv1d(8, 256, kernel_size=256, stride=64)

Sigmoid + 원소별 곱: 한쪽 Conv 출력에 Sigmoid를 적용해 조절할 값을 만들고, 다른 Conv 출력과 같은 위치끼리 곱함.
g = torch.sigmoid(b)
out = a * g

Temporal Max Pooling(최대풀링): 256개 채널 각각에서 여러 위치의 값 중 최대값 하나씩을 선택함. 파일 하나당 총 256개의 값이 남음
torch.max(x, dim=2).values

Fully Connected: 최대 풀링으로 나온 256개 값을 받아 GCG에 전달할 전역 Context 벡터를 만듦
nn.Linear(256, 256)

Feature(각 위치에서 추출한 특징값)

Embed / 1D Conv / Sigmoid / 원소별 곱: Context와 같은 방식으로 진행

1×1 Conv: 각 위치에서 이웃 위치까지 같이 보지 않고, 같은 위치의 256개 채널 값을 이용해 새로운 특징값을 만듦
nn.Conv1d(256,256,kernel_size = 1, stride = 1, padding = 0)

LeakyReLU: 활성화 함수를 적용하고 Feature 시퀀스 X를 만듦
F.leaky_relu(x)

Global Channel Gating(GCG)
역할: 파일 전체의 정보인 Context를 이용해서 Feature의 각 위치에 있는 특징값을 얼마나 억제할지 조절함

Context g를 nn.Linear(C, C)와 tanh로 변환함
변환된 Context와 Feature의 각 위치를 내적해 위치별 값을 만듦
내적 결과에 Sigmoid를 적용해 0~1 사이의 게이트 값을 만듦
게이트 값을 원래 Feature에 곱해 각 위치의 특징값을 조절함

def gcg(self, X, g):
    z = torch.tanh(self.w(g))
    z = torch.unsqueeze(z, dim=2)
↓
    B, C, T = X.shape
    x_tmp = X.reshape(1, B * C, T)
↓
    x_tmp = F.conv1d(x_tmp, z, groups=B)
    gates = x_tmp.view(B, 1, T)
↓
    return X * torch.sigmoid(gates)

최종 분류

GCG에서 조절된 Feature를 다시 Temporal Max Pooling함
채널별 최대값 하나씩 총 256개의 값을 남김
마지막 Fully Connected의 출력 개수를 클래스 수에 맞춤
Softmax를 적용해 각 클래스에 대한 확률로 변환함

C = nn.Linear(256, 클래스수)
torch.softmax(C(x), dim=1)

결론

기존 Malconv는 메모리 사용량이 크며 입력 크기는 2MB로 제한
고정 메모리 Temporal Max Pooling을 적용해 파일 자르지 않고 메모리 사용량과 학습 시간 줄임
GCG를 적용해 파일 전체에서 얻은 Context를 이용하여 Feature의 각 위치를 조절하고, 서로 멀리 떨어진 특징 간의 관계를 학습할 수 있도록 함
실험 결과 MalConv with GCG는 GPU 메모리 2.2GB, 1 epoch당 4시간 5분을 사용했으며 EMBER2018에서 정확도 93.29%, AUC 98.04%를 기록함

MalConv2_GCG_final_commented.ipynb

0.04MB

def read_tokens(batch, ids, starts, width):
    # ids: 파일 번호, starts: 읽기 시작 위치, width: 읽을 바이트 수
    # 부족한 부분은 0으로 채우고, 실제 바이트 0~255는 토큰 1~256으로 바꿉니다.
    result = torch.zeros((len(ids), width), dtype=torch.int16)
    arr = result.numpy()
    for k, (idx, start) in enumerate(zip(ids, starts)):
        idx, start = int(idx), int(start)
        take = max(0, min(width, int(batch["lengths"][idx]) - start))
        if not take:
            continue
        if idx not in batch["handles"]:
            batch["handles"][idx] = open(batch["paths"][idx], "rb")
        handle = batch["handles"][idx]
        # 필요한 위치로 이동해 해당 구간만 읽습니다. 열린 파일은 같은 배치에서 재사용합니다.
        handle.seek(start)
        buf = handle.read(take)
        raw = np.frombuffer(buf, dtype=np.uint8)
        # 실제 byte 0/255는 토큰 1/256. EOF/패딩만 0.
        np.add(raw, 1, out=arr[k, :take], dtype=np.int16)
    return result

read_tokens(batch, ...)

이 함수가 실제로 파일 일부를 읽어 0~255 범위의 바이트값(그리고 padding 값)을 PyTorch 텐서로 만들어 주는 함수

청크 처리 코드는 PE구조를 나누는 코드가 아니라, 큰 파일의 바이트 범위를 메모리 효율적으로 읽는 코드

PE 헤더나 import table 등을 명시적으로 읽고 싶다면 별도 PE 파서 라이브러리를 사용

pefile
LIEF

Chunk

파일 전체
├─ 1차: Context branch 전체 스캔 → 채널별 최대값 context_out
└─ 2차: Feature branch 전체 스캔 → context_out을 사용해 채널별 최대값 feature_out
└─ FC layers → 최종 분류

청크별 결과를 이어붙이는게 아니라 컨볼루션 창(window) 단위로 전체 파일을 훑어 최대값 위치만 찾고, 학습 때는 그 위치만 다시 계산

exact_pool()은 전체 파일을 청크로 스캔해 채널별 max 위치를 찾고, 학습 시에는 그 위치의 입력만 재계산해 메모리 사용량을 줄이면서도 일반 MalConv의 global max pooling과 같은 결과를 만듦

자기소개서 작성

jju71 — Thu, 17 Sep 2026 18:49:13 +0900

채용환경의 급변

기업의 AI 도입
- AI 기반 이력서 분석으로 자동 스크리닝이 확대
채용공고 분석
지원자 평가 변화
- 경력 나열보다 직무 연관성, 구체적 성과 수치, 기업 문화 적합도가 중요

성공적인 이력서 & 자소서의 핵심 요소

기계 판독성
- 채용 공고의 핵심 키워드를 자연스럽게 포함해 AI 스크리닝에 대응
성과 중심 스토리
- 수치와 성과를 중심으로 경험을 일과된 이야기로 구성
개인 역량 차별화
- 일반적인 표현보다 구체적인 경험과 성과로 진정성 보여줌

채용공고 읽기의 새로운 방식

필수 요구사항
- '필수'항목은 반드시 포함하고, 요구조건 충족여부를 먼저 확인
우대사항
- '우대'항목은 추가 강점으로 활용해 차별화
숨은 역량
- 반복되는 단어와 표현에서 기업이 중시하는 역량을 찾아냄
기업 문화
- 공고의 톤과 가치관을 읽고 자신의 경험과 연결

프롬프트

당신은 기업의 채용담당자입니다.
아래 채용공고를 분석하여 회사가 지원자에게 요구하는 역량을 정리해주세요.

[채용공고]
여기에 채용공고 내용을 붙여넣으세요.
다음 형식으로 작성해주세요.
1. 담당하게 될 주요 업무
2. 필수요건과 우대사항
3. 이력서에 포함해야 할 핵심 키워드 5개
4. 각 키워드를 증명할 수 있는 경험의 예시
5. 면접에서 확인할 가능성이 높은 질문 3개

조건:
- 채용공고에 없는 내용을 임의로 추가하지 마세요.
- 중요도가 높은 순서대로 정리해주세요.
- 결과는 표 형태로 작성해주세요.
- 어려운 표현은 취업준비생이 이해하기 쉽게 설명해주세요

행동이 가장 중요
STAR 기법 활용

[채용공고 핵심 키워드]
1단계에서 추출한 핵심 키워드를 입력하세요.

[나의 경험]
- 교육 및 전공:
- 프로젝트:
- 담당 역할:
- 사용 기술:
- 아르바이트 및 대외활동:
- 자격증:
- 문제를 해결한 경험:
- 성과 또는 결과:

다음 형식으로 작성해주세요.
1. 핵심 키워드와 연결되는 나의 경험
2. 가장 활용도가 높은 대표 경험 2개
3. 각 경험을 STAR 방식으로 정리
   - Situation: 당시 상황
   - Task: 맡은 과제와 역할
   - Action: 실제로 수행한 행동
   - Result: 결과와 배운 점
4. 경험을 더욱 구체화하기 위해 필요한 추가 질문

조건:
- 제공하지 않은 경험이나 성과를 만들지 마세요.
- 수치가 없는 경우 임의의 숫자를 만들지 마세요.
- 관련 경험이 부족하면 교육, 프로젝트, 아르바이트 경험에서 찾아주세요.
- 모호한 내용은 ‘추가 확인 필요’라고 표시해주세요.

AI 말투가 티가나지 않게 유의

[대표 경험]
2단계에서 정리한 STAR 경험을 입력하세요.

[작성 요청]
1. 이력서에 사용할 프로젝트·경험 문장 3개
2. 지원 직무에 적합한 자기소개서 초안 500자 내외
3. 자기소개서에 반영된 핵심 키워드
4. 채용담당자 관점에서 부족하거나 보완할 부분
5. 검토 의견을 반영한 최종 수정본

작성 조건:
- 결론을 먼저 제시하는 두괄식으로 작성해주세요.
- 내가 실제로 수행한 행동과 역할이 드러나게 작성해주세요.
- 채용공고의 핵심 키워드를 자연스럽게 포함해주세요.
- ‘열정적입니다’, ‘최선을 다했습니다’, ‘성실합니다’와 같은 추상적인 표현은 줄여주세요.
- 과도하게 화려하거나 AI가 작성한 것처럼 보이는 표현은 사용하지 마세요.
- 입력하지 않은 경험, 기술, 성과, 수치는 만들지 마세요.
- 문장은 신입 지원자에게 어울리는 명확하고 자연스러운 말투로 작성해주세요.

AI로 마지막 검토 및 읽어보기
주변에 피드백 요청

내가 실제로 한 경험인가
지원 직무의 키워드가 들어갔는가
나의 행동과 결과가 보이는가
다른 지원자도 쓸 수 있는 뻔한 문장은 없는가

2_화면설계

jju71 — Mon, 14 Sep 2026 01:26:52 +0900

1. UI 요구 사항 확인

UI(User Interface)

사용자와 시스템 사이에서 의사소통

UX(User Experience)

시스템•서비스 등을 사용자가 직/간접적으로 경험

UI 유형

CLI(Command Line Interface): 텍스트 기반
GUI(Graphic User Interface): 그래픽 반응 기반
NUI(Natural User Interface): 사용자 반응 기반
OUI(Organic User Interface): 유기적 상호작용 기반

UI 설계 원칙

직관성(Intuitiveness): 누구나 쉽게 이해하고 쉽게 사용할 수 있어야 함.(쉬운 검색, 쉬운 사용성, 일관성)
유효성(Efficiency): 정확하고 완벽하게 사용자의 목표가 달성될 수 있도록 제작(쉬운 오류 처리 및 복구)
학습성(Learnability): 초보와 숙련자 모두가 쉽게 배우고 사용할 수 있게 제작(쉽게 학습, 쉬운 접근, 쉽게 기억)
유연성(Flexibility): 사용자의 요구사항을 최대한 수용하고 실수를 방지할 수 있도록 제작(오류 예방, 실수 포용, 오류 감지)

PE 악성코드 이상탐지(정리 필요)

jju71 — Mon, 14 Sep 2026 01:15:18 +0900

사전 지식.pdf

4.41MB

정적분석이랑 데이터셋도 위로 올려서 ppt 구현 순서대로 정리 > 백엔드, 프론트엔드, FastAPI, React > 나한테 필요한 추가 지식

1,2차 파이프라인

1차 모델_XGBoost

결정트리(Decision Tree)는 "이 값이 기준보다 큰가?" 같은 질문을 차례로 하며 샘플을 나누는 분류 방식

Gradient Boosting은 처음 만든 단순한 트리의 틀린 부분을 다음 트리가 조금씩 보완하는 방식

값 하나하나는 위험점수가 아니다.

2차 모델_MalConv2

파일의 원시 바이트 데이터를 직접 분석해 악성코드를 탐지하는 딥러닝 기반의 보안 모델

학습 과정에서 어떤 바이트 패턴이 정상•악성 라벨과 관련이 있는지 찾는다고 이해

임배딩: 바이트마다 '숫자 설명 카드'를 붙이기
합성곱: 작은 범위를 보면서 같은 검사 방식을 반복 적용하는 연산
게이트: 신호의 통과 정도를 조절하는 장치
풀링: 최종 분류기는 일정한 크기의 입력을 받는 편이 편리하므로, 긴 패턴 신호를 요약

작동원리

기존의 1D-CNN 모델들은 파일 크기에 비례하여 GPU 메모리 사용량이 선형적으로 증가하는 치명적인 단점이 존재합니다. MalConv2는 이를 해결하기 위해 상수 메모리(Constant Memory) 관리 구조를 도입했습니다

상수 메모리 템포럴 맥스 풀링(Constant-Memory Temporal Max Pooling)
- 전체 파일의 활성화 맵을 통쨰로 메모리에 올리는 대신, 파일을 오버랩되는 작은 청크(Chunk) 단위로 쪼개어 스캔
- 각 채널별로 청크 내 최고 활성화 값(과 인덱스)만 추적하고 글로벌하게 비교하기 때문에, 파일 크기가 무한히 커져도 메모리 사용량은 일정 수준으로 억제
글로벌 채널 게이팅(GCG, Global Channel Gating)
- 파일 전체 레이어에 걸쳐 추출된 특징(Feature)들이 서로 어떻게 상호작용하는지 글로벌한 맥락에서 학습할 수 있게 하여 탐지 성능을 올림
- 메모리 절약을 통해 확보한 컴퓨터 자원의 여유를 활용해, 모델의 탐지 성능을 높이는 글로벌 채널 게이팅(GCG) 레이어를 추가
맥스 풀링의 단위성
- 악성코드의 핵심 시그니처(예: 특정 셀코드, 악성URL) 는 파일 내 특정 바이트 영역에 아주 극소적으로 집중되어 있음
- 에버리지 풀링(Average Pooling)을 쓰면 무의미한 더미 바이트들에 희석되기 때문에, MalConv2는 가장 강한 신호만을 보존하는 템포럴 맥스 풀링선택

https://github.com/FutureComputing4AI/MalConv2

GitHub - FutureComputing4AI/MalConv2: Classifying Sequences of Extreme Length with Constant Memory Applied to Malware Detection

Classifying Sequences of Extreme Length with Constant Memory Applied to Malware Detection - FutureComputing4AI/MalConv2

github.com

	머신러닝	딥러닝
데이터 형태	엑셀이나 DB 형태의 정형 데이터(Structured Data)	이미지, 음성, 텍스트, 비디오 같은 비정형 데이터(Unstructured Data)
특징 추출	사람이 직접 데이터를 분석하여 '의미있는 변수'를 가공하고 추출해 모델에 입력해야 성능이 나옴	데이터 원본(Raw Data)을 그대로 입력해도 신경망 계층(Hidden Layers)을 거치며 인공지능이 스스로 특징을 추출
설명 가능성	어떤 변수의 영향력이 컸는지를 수학적으로 밝히기 쉬움	높은 정확도를 제공하지만 내부 작동 원리를 직관적으로 이해하기 어려운 블랙박스 특성
데이터량 및 자원	비교적 적은 데이터라도 우수한 성능을 내며, 일반 CPU에서도 빠르게 학습	방대한 데이터가 있어야 과적합을 피할 수 있고, 고성능 GPU 연산 자원이 필수적

SHA256(Secure Hash Algorithm 256-bit)

임의 데이터 입력 시 256비트(64자리 16진수) 고정 길이 문자열(해시값)로 변환하는 단방향 암호화 해시함수

무결성 검증: 파일 변경 여부를 즉시 감지(1바이트만 변해도 완전히 다른 해시 출력)
악성코드 식별: VirusTotal 등에서 파일 단위 고유 ID(IoC)로 활용

본 프로젝트에서는 중복값을 제거하는 데에 사용됨

Chunk

대용량 데이터를 한 번에 처리하기 어려울 때 작게 나누어 다루는 하나의 '분량 단위'나 '조각'

React + FastAPI 조합의 장점

빠른 개발 속도 및 생태계
- FastAPI가 제공하는 자동 Swagger UI(/docs) 덕분에 프론트엔드와 백엔드 간 API 명세 공유 및 테스트가 매우 용이
AI / ML / 데이터 처리 연동
- 백엔드가 Python 기반이므로 PyTorch, TensorFlow, Pandas 등 풍부한 AI/데이터 분석 라이브러리를 React UI와 손쉽게 연결 가능
높은 성능과 생산성
- FastAPI의 비동기 처리(async/await) 능력과 React의 효율적인 렌더링 방식이 결합하여 높은 반응성을 제공

Mock

실제 데이터나 시스템을 흉내내어 만든 가짜(대체) 데이터나 객체

상황: 실제 AI 모델, 데이터베이스, 또는 외부 API가 아직 완성되지 않았거나 연동하기 복잡한 상태
해결 (Mock 구현): 입력값(예: 텍스트나 사용자 이름 등)을 SHA-256 해시 함수에 통과시키면, 항상 고유하지만 무작위로 보이는 문자열(결과값)이 출력. 이 해시값의 성질을 이용해 "항상 일정한 형태의 가짜 라벨과 점수"를 찍어내는 가짜 함수(Mock)를 만드는 것입니다.

Why?

재현 가능성(Determinism): 똑같은 입력값을 넣으면 항상 똑같은 '가짜 점수와 라벨'이 나오기 때문에, 테스트를 할 때 결과가 일관적
독립적인 개발: 진짜 AI 모델이나 무거운 서버가 준비되지 않아도 프론트엔드나 다른 로직이 정상적으로 작동하는지 미리 테스트 가능

정적분석

정적 분석은 헤더, 섹션, 바이트 분포, 문자열, Import 등 저장된 정보를 읽는다.

동적 분석은 실행 중 생성 파일, 프로세스, 네트워크 통신 등을 관찰한다

본 프로젝트의 입력 특징은 정적 정보

Packing(패킹)

프로그램 코드를 압축하거나 감싸는 작업

본 프로젝트에서 필요한 것은 패커를 해제하는 구현보다 패킹에 의한 분포 변화, 파싱 경고, 누락 특징을 평가하고 한계를 설명하는 능력

Obfuscation(난독화)

코드를 읽거나 분석하기 어렵게 만드는 변형

Dataset

정보보안_악성코드 이상탐지

jju71 — Sat, 12 Sep 2026 22:38:05 +0900

기본 용어

운영체제, OS	Windows나 macOS처럼 프로그램 실행과 컴퓨터 자원 관리를 담당하는 기본 소프트웨어
CPU	프로그램의 명령을 실제로 처리하는 장치
코드	컴퓨터가 무엇을 하라고 지시하는 명령
데이터	코드가 처리하는 숫자, 글자, 이미지 등의 내용
파일	디스크에 저장된 정보의 묶음
메모리, RAM	실행 중인 프로그램과 데이터를 펼쳐 놓은 작업 공간
프로세스	프로그램이 실행되어 활동 중인 상태
바이너리	정보를 0과 1로 표현한 것. 주로 실행파일의 실제 바이트 내용
바이트, Byte	8개의 비트로 이루어진 정보 단위. 한 바이트는 0~255 값을 표현
16진수	숫자를 0~9와 A~F로 쓰는 표기법. 파일의 바이트와 주소를 짧게 표현할 떄 사용

1. 파일 실행

정적 분석: 파일 내용을 읽음
동적 분석: 실행 중 행동을 관찰

2. PE

Windows 실행파일에 사용하는 내부 구조의 약속

.exe	보통 사용자가 실행하는 프로그램
.dll	여러 프로그램이 가져다 쓰는 기능 모음
.sys	주로 드라이버 같은 시스템 구성요소
.scr	화면보호기 실행파일

DOS Header

MZ 표식과 PE 헤더 위치를 찾는 정보

파일 앞부분의 기본 정보와 PE 헤더 위치 정보

PE Header

대상 CPU 종류와 섹션 개수 등 기본 정보

Optional Header

진입점(실행 시작 위치), 메모리 배치(기존 주소, 전체 크기 etc) 등의 정보

Section Table

각 구역의 위치•크기•권한을 적은 목록

Section

실행 코드, 데이터, 이미지 등을 담는 구역

섹션	의미	예시
.text	실행 명령이 들어있는 구역	계산하기, 파일 저장하기를 수행하는 코드
.data	실행 중 바뀔 수 있는 데이터 구역	초기값이 있는 전역 변수
.rdata	주로 읽기 전용 데이터 구역	고정된 문자열이나 상수
.rsrc	프로그램에 딸린 리소스 구역	아이콘, 대화상자, 버전 정보
.reloc	메모리 위치가 달라졌을 때 주소를 조정하는 정보	이동 후 주소 보정 목록

헤더 = 설명 정보
섹션 = 역할별 구역
섹션 테이블 = 구역 안내도

3. Entry Point와 주소

Entry Point

진입점은 실행을 시작하도록 지정된 위치

주소 용어	위치의 기준
FIle Offset	디스크 파일의 맨 앞에서 얼마나(몇 바이트) 떨어져 있는가?
RVA	메모리에 올라간 프로그램 시작 위치에서 얼마나 떨어져 있는가?
VA	프로세스의 가상 메모리 공간에서 사용하는 주소
imageBase	프로그램을 메모리에 배치하려는 기준 주소

4. 감염의 실행흐름

사용자가 프로그램 실행
Loader, 로더라는 Windows의 로딩 기능이 파일 구조를 읽음
코드와 데이터를 메모리에 배치하고 필요한 준비를 함
지정된 실행 흐름에 따라 프로그램이 동작

악성코드, Malware는 정보 탈취나 파일 훼손 등 악의적인 기능을 수행하는 소프트웨어
File Infector, 파일 감염형 악성코드는 기존 실행파일을 변조해서 자기 코드가 실행되도록 만드는 유형

가능한 변화	가질 수 있는 의문점
새 섹션 추가	기존에 없던 구역이 생겼는가?
기존 구역 • 빈 공간 이용	섹션 수는 같아도 내용이 바뀌었는가?
기존 실행 코드 수정	명령이 달라져 실행 경로가 바뀌었는가?

5. 구조를 읽는 비교 리스트

같은 프로그램의 정상 원본과 감염된 버전이 있을 때 어디를 비교할까?

필드
Machine	대상 CPU 종류
NumberOfSection	섹션 개수
AddressOfEntryPoint	진입점 RVA
VirtualAddress / VirtualSize	섹션의 메모리상 시작 RVA / 메모리상 크기
PointerToRawData / SizeOfRawData	섹션의 파일상 시작 위치 / 저장된 데이터 크기
SizeOfImage / SizeOfCode	메모리 이미지 전체 크기 / 코드 영역 크기 정보
SectionAlignment / FileAlignment	메모리 / 파일에서 위치를 맞추는 단위
CheckSum	검사값
TimeDataStamp	시간 관련 필드

Alignment, 정렬: 책의 새 장을 일정한 페이지 단위에 맞춰 시작하는 것

권한, 기능목록, 바이트 분포, 추가 데이터 확인 필요

RWX

내용을 바꿀 수도 있고 실행할 수도 있는 구역

R + W : 수정할 데이터 구역
R + X : 실행 코드 구역

Import Table, 임포트 테이블

프로그램이 외부에서 가져다 쓰는 기능의 목록

DLL: 기능을 모아 놓은 도구 상자
API: 프로그램이 그 기능을 요청하는 정해진 사용 방식
Import Table: 이번 도구 상자에서 어떤 기능을 가져오는지 적는 목록

자료의 API

API	하는 일	정상적인 사용 예
CreateFile	파일 등을 만들거나 열기	문서 열기
WriteFile	파일 등에 데이터 쓰기	문서 저장
CreateProcess	새 프로세스 시작	다른 프로그램 실행
VirtualAlloc	가상 메모리 공간 확보	처리에 필요한 메모리 준비

Registry, 레지스트리

Windows와 프로그램의 설정을 저장하는 체계

6. Entropy

Entropy, 엔트로피

바이트 값의 분포가 얼마나 고르게 퍼져 있는지를 나타내는 통계량

같은 값이 계속 반복되면 낮아짐
여러 값이 고르게 나타나면 높아짐
- 일반적인 바이트 기반 Shannon 엔트로피는 0~8 범위

높은 엔트로피는 압축이나 암호화된 내용이 있을 가능성을 보여줌

용어	의미
압축	정보를 더 작은 크기로 저장하는 것
암호화	키 없이는 내용을 해석하기 어렵게 바꾸는 것
패킹, Packing	실행파일의 코드 등을 압축•변환해 담고, 실행할 떄 풀어 사용하는 방식
난독화	코드의 의미나 흐름을 이해하기 어렵게 만드는 것

7. Byte Diff

파일의 바이트차이를 비교하는 작업

원본: A B C D E F
변경본: A B X C D E F

➔ 발생하는 문제점

방식	하는 일
Raw Byte Diff	실제 바이트가 어떻게 달라졌는지 비교
PE Structure-aware Diff	헤더는 헤더끼리, 대응하는 섹션은 섹션끼리 구조를 이해하면서 비교

Byte Range

변경된 연속 구간

8. 핵심 분석 우선순위

Entry Point 변화
새로운 Section 추가 여부
.text 영역의 변경 바이트
Section Table 변화
변경 ByteRange
NumberOfSection
SizeOfImage, SizeOfCode
Import Table 변화
Section Entropy 변화
Overlay 존재 여부

핵심은 단순히 바이트가 얼마나 달라졌는가가 아니라,

감염으로 변경된 바이트가 PE구조의 어느 영역에 위치하고, 그 변화가 프로그램 실행 흐름에 어떤 영향을 주었는지를 확인하는 것

9. 추가로 필요한 지식

항목	필요 이유	목표
바이너리 읽기	PE는 일반 글자 파일이 아님	바이트, 16진수, 오프셋 이해
엔디언, Endianness	여러 바이트로 된 숫자의 저장 순서를 해석해야 함	Little-endian의 의미 이해
PE 파싱	헤더와 섹션을 구조화된 값으로 추출	필드와 섹션 목록 읽기
파일 주소 ↔︎ 메모리 주소	잘못된 위치를 비교하지 않기 위해	Offset과 RVA 구분
정적•동적 분석	분석 범위와 환경이 달라짐	실행하지 않고 알 수 있는 것 구분
특징 추출	파일을 모델이 처리할 숫자로 변환	섹션 수, 크기, 엔트로피 등 추출
데이터셋과 라벨	모델의 정답 근거가 필요	수집 출처와 정상•악성 판정 근거 확인
평가 지표	실제 탐지 성능을 설명	오탐•미탐, 정밀도•재현율 이해

Parsing,파싱 은 정해진 형식에 맞춰 데이터를 읽어 의미있는 항목으로 나누는 작업

프로젝트에 적용_머신러닝

데이터누수: 같은 파일이나 매우 비슷한 변종이 학습용과 시험용에 섞이면 성능이 부풀려질 수 있음
잘못된 단서 학습: 정상파일은 ARM용, 악성파일은 x86용으로만 모으면 모델이 악성 여부 대신 CPU 차이를 배울 수 있음
정상 업데이트 포함: 업데이트된 정상파일도 시험해서 단순 변경을 악성으로 오해하는지 확인 필요
검증용과 시험용 분리: 기준값을 조절하는 데이터와 최종 성능을 재는 데이터 구분필요

오탐, False Positive	정상인데 악성 또는 이상이라고 경보했는가?
미탐, False Negative	악성인데 놓쳤는가?
Precision, 정밀도	경보한 것 중 실제 악성은 얼마나 되는가?
Recall, 재현율	실제 악성 중 얼마나 찾아냈는가?

원본 파일과 비교 파일을 입력
PE 형식인지 검사하고 헤더•섹션 정보를 읽음
진입점, 섹션, 권한, 크기, 임포트, 엔트로피 비교
바뀐 구간을 해당 PE 영역에 연결해서 표시
관찰된 사실과 추가 조사가 필요한 이유를 보여줌

악성코드 계열

유형	설명	공격 목적
Dialer, 다이얼러	전화 모뎀의 연결 번호 등을 바꾸어 원치 않는 전화 연결을 시키는 프로그램	고액 통화료를 발생시켜 수익 획득 주로 과거 전화선 인터넷 환경과 관련
Backdoor, 백도어	공격자가 컴퓨터에 다시 들어오거나 명령할 수 있는 뒷문	원격 조정, 정보 수집, 추가 악성 코드 실행
Worm, 웜	자신을 복제해 다른 장치나 컴퓨터로 퍼지는 악성코드	감염 범위 확대 추가 피해 기능은 계열마다 다름
Trojan, 트로이 목마	정상 • 유용한 파일처럼 보이거나 다른 프로그램에 섞여 악성 기능을 수행	유형명이 넓어서 구체적인 목적은 샘플 분석 필요
TrojanDownloader, 다운로더	다른 악성 프로그램을 내려받는 역할	후속 악성코드를 설치하는 발판
Rogue, 가짜 보안 프로그램	백신처럼 꾸미고 거짓 감염 경고를 보여줌	치료 • 제품 구매 명목의 결제 유도
PWS, Password Stealer	계정과 비밀번호를 훔치는 프로그램	계정 탈취, 정보 유출

악성코드 종류

종류	자료의 유형	설명
Adialer.C	Dialer	유형 기준: 원치 않는 전화 연결이나 고액 과금을 유발하는 다이얼러. .C 변종의 구체적인 연결 대상은 별도 확인 필요
Agent.FYI	Backdoor	유형 기준: 공격자가 외부에서 접근하고 명령할 수 있도록 하는 백도어. 이름만으로 특정 원격제어 기능까지 확장할 수 없음
Allaple.A	Worm	계열 기준: 네트워크로 퍼지고 특정 웹 사이트에 서비스 거부 공격을 수행하는 Allaple 계열. 감염 확산과 서비스 방해에 사용
Allaple.L	Worm	Allaple 관련 분류. 계열 수준의 목적은 위와 같지만, .A와 .L의 정확한 기능 차이는 표만으로 알 수 없음
Alueron.gen!J	Worm	자료 기준: 웜으로 분류되어 있어 자기 복제•전파 관점에서 이해 이름이 비슷한 다른 계열과 곧바로 동일시하면 안됨
Autoren.K	Worm: AutoIT	유형 기준: AutoIT 관련 웜 분류. 자기 복제•확산에 해당하며, 실제 전파 경로는 샘플 확인 필요. AutoIt 자체는 정상적인 자동화 도구
C2LOP.P	Trojan	유형 기준: 트로이목마. 은밀한 악성 기능 수행이라는 넓은 분류이며, 정보 탈취•광고•설정 변경 중 무엇을 하는지는 추가 확인 필요
C2LOP.gen!g	Trojan	C2LOP 관련 트로이목마 분류. .P와 기능이 동일하다고 단정할 수 없음
Dialplatform.B	Dialer	유형 기준: 전화 연결을 악용하는 다이얼러. 원치 않은 과금 등을 유발하는 유형
Dontovo.A	TrojanDownloader	유형 기준: 후속 악성 프로그램을 다운로드하는 역할. 추가 감염의 발판
Fakerean	Rogue	계열 기준: 가짜 백신 검사와 거짓 감염 경고를 보여주고, 치료하려면 결제하라고 속이는 계열
Instantaccess	Dialer	유형 기준: 원치 않은 전화 연결과 과금에 관련된 다이얼러
Lolyda.AA1	PWS	유형 기준: 계정•비밀번호 탈취형. 정확히 어느 서비스의 계정을 노리는지는 표만으로 알 수 없음
Lolyda.AA2	PWS	같은 Lolyda 관련 비밀번호 탈취 분류. AA1과의 세부차이는 별도 분석 필요
Lolyda.AA3	PWS	같은 Lolyda 관련 비밀번호 탈취 분류. 다른 접미사의 샘플과 기능이 완전히 같다는 보장이 없음
Malex.gen!J	Trojan	유형 기준: 트로이목마 정확한 피해 기능은 이름•유형만으로 특정하기 어려움
Obfuscator.AD	TrojanDownloader	자료 기준: 추가 악성 프로그램을 내려 받는 분류 이름의 'Obfuscator'만으로 특정 난독화 방식까지는 알 수 없음
Rbot!gen	Backdoor	계열 기준: 공격자가 원격 명령을 내리는 봇•백도어 게열 정보 수집, 추가 파일 실행, 서비스 거부 공격 등에 사용
Skintrim.N	Trojan	유형 기준: 트로이목마 세부 목적과 행동은 개별 샘플 확인 필요
Swizzor.gen!E	TrojanDownloader	유형 기준: 후속 악성 프로그램을 내려받는 역할
Swizzor.gen!I	TrojanDownloader	Swizzor 관련 다운로드 분류 .E와 !I의 차이가 특정 기능 차이라는 뜻은 아님
VB.AT	Worm	유형 기준: 자기복제•전파형 구체적인 전파 수단과 추가 피해 기능은 별도 확인 필요
Wintrim.BX	TrojanDownloader	유형 기준: 추가 악성 프로그램 다운로드를 통한 후속 감염에 사용
Yuner.A	Worm	유형 기준: 자기복제•전파형 이름만으로 정상 PE에 코드를 삽입하는 감염 방식이라고 판단할 수 없음

Model

1_요구사항 확인

jju71 — Sat, 12 Sep 2026 21:08:17 +0900

기능 요구사항 = 업무 프로세스

클라이언트가 정의: 입력, 출력, 연산

비기능 요구사항

웹서비스는 24시간 구동되어야 한다
시스템을 동작시키기 위한 HW 최대 사양은 ...

소프트웨어 개발 방법론

객체 지향 방법론(Object-Oriented Development): 객체라는 기본 단위로 시스템을 분석(추상화) 및 설계하는 방법론

애자일 방법론(Agile Development): 변화에 유연하고 신속하게 적응, 신속 적응적 경량 개발 방법론

XP(eXtreme Programming)
- 지속적인 통합(CI; Continuous Integration): 매일 여러번씩 소프트웨어를 통합하고 빌드해야 한다는 원리
- 작은 릴리즈(Small Release): 작은 시스템을 먼저 만들고, 짧은 단위로 업데이트한다는 원리
- 테스트 기반 개발(TDD; Test Driven Development): 작성할 프로그램에 대한 테스트를 먼저 수행하고, 이를 통과할 수 있도록 실제 코드를 작성한다는 원리
- 리팩토링(Refactoring): 프로그램의 기능을 바꾸지 않으면서 중복제거, 단순화 등을 위해 시스템을 재구성한다는 원리(좋은 알고리즘 & 자료구조)
스크럼(Scrum): 매일 정해진 장소에서 짧은 시간의 개발을 하는 팀
- 백로그: 제품에 반영되어야 하는 요구사항, 기능, 개선점, 버그 수정 등을 망라한 작업목록 / 우선순위가 수시로 변경, 사용자 관점에서 기술
- 번 다운 차트(Burn Down Chart): 남아있는 백로그 대비 시간을 그래픽적으로 표현한 차트, 백로그는 보통 수직축, 시간은 수평축에 위치

객체 지향 분석 방법론

클래스: 하나 이상의 유사한 객체들을 묶어서 하나의 공통된 특성을 표현

객체: 자신과 다른 것을 식별 가능한 대상, 인스턴스와 비슷

메서드

메시지: 객체 간의 상호 작용은 메시지를 통해 이루어짐

인스턴스: 클래스를 통해 실제의 실현 객체

속성: 한 클래스 내에 속한 객체들이 가지고 있는 데이터 값들을 단위별로 정의

객체 지향 기법

클래스를 정의할 때 어떤 것을 고려해야하나?

캡슐화(Encapsulation)
- 인터페이스만 밖으로 드러내는 기법
- 결합도가 낮아지고 재사용 용이
- 정보은닉과 깊은 관계
상속성(Ingeritance): 상위클래스의 속성과 메서드를 하위 클래스에서 재정의 없이 물려받아 사용하는 기법
다형성(Polymorphism)
- 오버로딩(Overloading): 매개변수의 유형과 개수를 다르게 하여 같은 이름의 메서드를 여러개 가지는 기법
- 오버라이딩(Overriding): 상위 클래스에서 정의한 일반 메서드의 구현을 하위 클래스에서 무시하고 재정의할 수 있는 기법
추상화(Abstraction)
- 공통 성질을 추출하여 추상클래스를 설정
- abstract class, interface
정보 은닉(Information Hiding): 공개 인터페이스를 통해서만 접근 가능하도록 하는 코드 보안 기술
- 독립성을 유지하는 데 도움
관계성(Relationship)

객체 지향 설계 원칙(SOLID)

단일 책임의 원칙(SRP; Single Responsibility Principle)
- 하나의 클래스는 하나의 목적을 위해 생성
- 여러가지 기능을 하나의 클래스에 구현 ❌
- 모듈(한가지 기능만) ➞ OOP(객체 ➔ 클래스)
개방 폐쇄 원칙(OCP; Open Close Principle)
- 소프트웨어의 구성요소(컴포넌트, 클래스, 모듈, 함수)는 확장에는 열려있고, 변경에는 닫혀있어야 함
리스코프 치환의 원칙(LSP; Liskow Substitution Priciple)
- 서브타입(상속받은 하위 클래스)은 어디서나 자신의 기반 타입(상위 클래스)으로 교체할 수 있어야 함 ➞ 업스케일링
인터페이스 분리의 원칙(ISP; Interface Segragation Principle)
- 한 클래스는 자신이 사용하지 않은 인터페이스는 구현하지 말아야 함
- 특정 기능에 대한 인터페이스는 상관없는 부분이 변해도 영향을 받지 않아야 함
의존성 역전의 원칙(DIP; Dependency Inversion Principle)
- 상위 클래스는 하위 클래스에 의존해서는 안되고, 둘 다 추상화에 의존(abstract class, interface로 구현)

객체 지향 분석 방법론 종류

분석 결과를 어떻게 도식화할까?

럼바우
- 객체모델링(=정보 모델링; object modeling / information modeling): ER 다이어그램 작성
- 동적모델링(Dynamic modeling): 상태 다이어그램
- 기능 모델링(Functional modeling): 자료 흐름도(DFD)

프로젝트 관리

비용산정 모형

하향식 산정방법
- 전문가 문의
상향식 산정방법
- code 라인 수

비용산정 모형 종류

COCOMO(Constructive Cost Model)
- 조직형(Organic Mode): 5만 라인 이하
- 반분리형(Semi-Detached Mode): 30만 라인 이하
- 임베디드형(Embedded Mode) = 내장형 : 30만 라인 이상의 소프트웨어를 개발하는 유형

현행 시스템 분석

소프트웨어 아키텍쳐 패턴 유형

계층화 패턴(Layered Pattern)
- 서로 마주보는 두 계층 사이에서만 상호작용
클라이언트-서버패턴(Client-Server Pattern)
- 클라이언트를 통해 서버에 서비스를 요청
- 서버는 계속 클라이언트로부터 요청을 대기 + 연산
파이프-필터 패턴(Pipe-FIlter Pattern)
- 서브 시스템이 입력 데이터를 받아 처리
- 결과를 다음 서브 시스템으로 넘겨주는 과정을 반복
브로커 패턴(Broker Pattern)
- 분산 시스템
모델-뷰-컨트롤러 패턴(MVC; Model VIew Controller)
- 모델 = 연산
- 뷰 = 연산 결과 display
- 컨트롤러 = 사용자 요청 / 연산결과 전달
- 결합도 감소 및 유지보수가 용이
  - 화면 디자인이 변경되면 뷰만 수정하면 됨
- 역할분담
  - Frotend 개발자 = view 구현
  - Backend 개발자 = Model, Controller
- 코드 재사용성이 증가

디자인 패턴

class 정의, 인스턴스 생성방법, 메시지 구현 방법 ⇒ Solution

About 공통으로 발생하는 문제

목적
- 생성 = 인스턴스: 인스턴스 생성, 객체 생성 방식
- 구조 = 변수, 클래스의 조합: 클래스나 객체의 조합
- 행위 = 메서드 = 메시지
범위
- 클래스
- 객체

디자인 패턴 종류

생성 패턴

Factory Method(팩토리 메서드)
- 상위 클래스에서 객체를 생성하는 인터페이스를 정의, 하위클래스에서 인스턴스를 생성하도록 하는 방식
- 객체 생성은 자식 클래스에게 맡긴다
- 예) 로그인 ➔ 네이버 / 카카오 / 구글
Builder(빌더)
- 객체의 생성 방법과 표현 방법을 분리
- 객체를 선별해서 생성
- 예) 회원정보 속성 10개 ➔ 입력: 이름, 전화번호
Prototype(프로토타입)
- 일반적인 원형(Sample)을 만들어 놓고 복사한 후 필요한 부분만 수정
- 기존 객체를 복사해서 사용
Abstract Factory(추상 팩토리)
- 클래스에 의존하지 않고 서로 연관•의존적인 객체들의 조합을 만드는 인터페이스를 제공하는 패턴
- 관련있는 객체들의 세트를 한번에 생성
- 예) 라이트 / 다크모드: 배경, 버튼색, 텍스트 색
Singleton(싱글톤)
- 객체를 하나만 생성하도록
- 이 클래스의 인스턴스는 1개만 생성하겠다

구조 패턴

Bridge
- 구현부와 추상부를 독립적으로 확장
Decorator
- 기존 Code 수정없이 기능을 추가
- Java 입출력 스트림
Facade
- 복잡한 하위시스템들에 대한 하나의 인터페이스를 열어줌
- 예) 영상 play ➔ 조명, 음향, 스크린
Flyweight
- 공통으로 사용하는 객체에는 메모리를 공유
Proxy
- 실제 객체에 접근하기 전에 대리인 객체를 먼저 접근
- 용량 큰 이미지 display
Composite
- 단일 객체와 복합 객체를 동일하게 처리할 때 파일과 폴더는 동일한 객체로 처리
Adapter
- 호환되지 않는 두 인터페이스를 연곂

행위 패턴

어떻게 통신 / 메시지 & 메서드

Mediator
- 객체끼리 직접 소통❌, 중재자를 통해서만 소통
- 채팅방
Interpreter
- 문장 해석기 구현
- embedded SQL의 SQL 쿼리 파서(Parsing)
Iterator
- 내부구조를 몰라도 데이터 목록을 순서대로 꺼내줌
- embedded SQL ➔ 커서
Template Method
- 전체적인 틀을 정해두고, 세부단계만 자식이 구현
Observer
- 객체의 상태가 바뀌면 다른 객체에 자동으로 알려줌
- 주식 패턴
- 실시간 변경
State
- 객체의 상태에 따라서 행동 변경
- 쇼핑몰 주문상태(주문 대기 > 결제 완료 > 배송 중 > ...)
Visitor
- 데이터 구조는 유지하고, 새로운 기능만 분리
- 파일 시스템 용량계산(파일을 순회한 후에 크기 sum)
Command
- 연산을 하나의 객체로 포장
- Ctrl + z
Strategy
- 알고리즘을 쉽게 끼었다 뺐다 할 수 있도록
- 결제 수단(신용카드, 카카오페이, 현금)
Memento
- 객체의 이전 상태를 저장하고 언제든 되돌릴 수 있게
- 임시 저장
Chain of Responsibility
- 요청 처리가 완료될 때까지 계속 다음 step으로 넘기는 경우
- unix 로그인 : 로그인 인증 > 파일별 권한 확인 > 로깅

OSI 7계층 (물데네전세표응)

응용계층(Application)
표현 계층(Presentation) : 데이터 형식 설정
세션 계층(Session): 연결 접속 및 동기 제어
전송 계층(Transport): 데이터 분할 및 재조립
네트워크 계층(Network): 최적화된 경로
데이터링크 계층(Data Link): 데이터 전송, 전송 오류 제어
물리 계층(Physical)

요구사항

요구공학(Requirements Engineering): 요구사항을 도출•분석•명세•확인 및 검증하는 구조화된 활동

요구사항 도출

도출(Elication)
분석(Analysis)
명세(Specification)
확인 및 검증(Validation & Verfication)

객체 지향 분석: 모델링 표기를 UML로 표준화

NLP

jju71 — Fri, 11 Sep 2026 22:02:17 +0900

1. 자연어

자연어는 인간이 일상적으로 의사소통에 사용하는 언어로, 말과 글을 통해 표현되는 언어를 말합니다. 자연어는 문법, 어휘, 맥락, 뉘앙스 등 복잡한 요소들로 이루어져 있고 규칙적인 구조와 함께 다양한 변형이 가능합니다. 컴퓨터 과학에서는 이러한 자연어를 이해하고 처리하기 위해 자연어 처리(NLP, Natural Language Processing) 기술이 사용되며, 이를 통해 텍스트 분석, 번역, 음성 인식, 챗봇과 같은 다양한 응용이 가능합니다. 자연어는 인간의 사고와 문화적 배경을 반영하므로, 이를 다루는 기술은 인문학적 이해와 기술적 접근이 결합되어야 합니다.

2. 자연어 처리

자연어 처리는(Natural Language Processing, NLP) 컴퓨터가 인간의 언어를 이해하고 처리하며 생성할 수 있도록 돕는 인공지능 기술 분야입니다. 이를 통해 텍스트나 음성 데이터를 분석하고, 번역, 요약, 감정 분석, 질의응답, 음성인식 등 다양한 작업을 수행할 수 있습니다. 자연어 처리는 언어학, 컴퓨터 과학, 인공지능의 융합으로 이루어지며, 형태소 분석, 구문 분석, 의미 분석 등 여러 단계를 포함합니다. 최근에는 딥러닝 기술과 대규모 언어 모델의 발전으로 자연어 처리 성능이 크게 향상되어 챗봇, 검색 엔진, 추천 시스템과 같은 실생활 응용에서 널리 사용되고 있습니다.

텍스트 분류
감정 분석
문서 요약
기계 번역
질의 응답
정보 검색
챗봇
문장 생성
RAG
LLM 기반 Agent

최근에는 자연어 처리 기술이 이미지, 음성, 영상 등의 데이터와 결합하면서 Multimodal AI로 확장

Corpus

Corpus(말뭉치)는 자연어 처리에서 분석하거나 학습하기 위해 수집한 전체 텍스트 데이터의 집합

Document

Corpus를 구성하는 각각의 텍스트 데이터
Document라고 해서 반드시 긴 문서를 의미하는 것은 아님
예) 뉴스 기사 하나, 리뷰 하나, 댓글 하나, 문자 하나 등

3. Tokenization

텍스트를 모델이 처리할 수 있는 작은 단위만 Token으로 나누는 과정
https://platform.openai.com/tokenizer

OpenAI Platform

platform.openai.com

토큰

토큰은 모델이 처리하는 텍스트의 작은 단위
하나의 토큰은 단어, 부분적인 단어, 공백이나 구두점일 수 있음
토큰은 반드시 단어 하나를 의미하지는 않음

Vocabulary

Vocabulary는 Tokenizer(토큰을 나눠주는 프로그램, 알고리즘)가 사용하는 토큰들의 집합
각 토큰(쪼개진 토큰)에는 고유한 정수 ID가 할당됨
정수 ID 자체는 언어적인 의미가 전혀 없음

허깅 페이스

허깅 페이스(Hugging Face)는 자연어 처리뿐 아니라 이미지, 음성, 영상, 멀티모달 모델을 공유하고 사용하는 데 필요한 여러 도구와 서비스를 제공하는 AI 생태계이자 회사 이름

https://huggingface.co/

Hugging Face – The AI community building the future.

We’re on a journey to advance and democratize artificial intelligence through open source and open science.

huggingface.co

import torch

if torch.cuda.is_available():
    DEVICE = torch.device('cuda')
elif torch.backends.mps.is_available():
    DEVICE = torch.device('mps')
elif torch.xpu.is_available():
    DEVICE = torch.device('xpu')
else:
    DEVICE = torch.device('cpu')

print(DEVICE)

text = "나는 자연어를 공부한다"
tokens = text.split()
# tokens
# PAD: 문장의 길이를 맞춰주기 위해서 빈자리에 0을 채워줌 > 사이즈를 맞춰줘야 함
# UNK: 알려지지 않은 토큰, 단어사전에 없으니까
vocab = {"<PAD>": 0, "<UNK>":1, "나는":2, "자연어를":3, "공부한다":4}
token_ids = [vocab.get(token, vocab['<UNK>']) for token in tokens]
# token_ids

input_ids = torch.tensor(token_ids, dtype=torch.long) # 모델에 넣을 수 있는 형태

print("원문: ", text)
print("Token: ", tokens)
print("Token ID: ", token_ids)
print("PyTorch Tensor: ", input_ids)
print("dtype: ", input_ids.dtype)
-----------------------------------------------------------------
원문:  나는 자연어를 공부한다
Token:  ['나는', '자연어를', '공부한다']
Token ID:  [2, 3, 4]
PyTorch Tensor:  tensor([2, 3, 4])
dtype:  torch.int64

# python3 -m pip install transformers
from transformers import AutoTokenizer

# 허깅 페이스 허브의 "klue/bert-base" Repository에서 Tokenizer 설정과 Voca를 불러옴
# 객체 생성
# vocabulary를 불러오는 키워드드, klue: 한국어 말뭉치가 가장 많고 잘 정리되어 있는 vocabulary
tokenizer = AutoTokenizer.from_pretrained("klue/bert-base")

text = "자연어 처리를 공부합니다."
tokens = tokenizer.tokenize(text) # 분리
print("Toekn: ", tokens)
# 형태소 분석기를 사용해서 분리

token_ids = tokenizer.convert_tokens_to_ids(tokens) # 숫자 변환
print("toekn ID: ", token_ids)
-----------------------------------------------------------
Toekn:  ['자연', '##어', '처리', '##를', '공부', '##합니다', '.']
toekn ID:  [3941, 2051, 4211, 2138, 4244, 11800, 18]

print("Vocabulary 크기: ", tokenizer.vocab_size)
print("[PAD] ID: ", tokenizer.pad_token_type_id) 
print("[UNK] ID: ", tokenizer.unk_token_id)
print("[CLS] ID: ", tokenizer.cls_token_id)
print("[SEP] ID: ", tokenizer.sep_token_id)
-------------------------------------------------
Vocabulary 크기:  32000
[PAD] ID:  0
[UNK] ID:  1
[CLS] ID:  2
[SEP] ID:  3

OOV

OOV(Out-Of-Vocabulary)는 Voca에 존재하지 않는 Token이 입력되는 문제
과거의 단어 단위 Voca에서는 처음 보는 단어를 <UNK>와 같은 Unknown Token으로 처리하는 경우가 빈번
현대 NLP에서는 Subword Tokenization을 이용하여 이 문제를 크게 줄임

vocab = {"<PAD>": 0, "<UNK>":1, "나는":2, "자연어를":3, "공부한다":4}
tokens = {"나는", "트랜스포머를", "공부한다"}
token_ids = [vocab.get(token, vocab['<UNK>']) for token in tokens]
print(token_ids)
------------------------------------------------------
[4, 2, 1]

Token ID

Tokenization이 끝나면 각각의 Token을 Vocabulary에 정의된 정수 ID로 변환

"오늘 날씨가 좋다" > Tokenization > [Token1, Token2, Token3, ... ] > Token ID > [102, 235, 303, ... ]

악성코드 이상탐지_트러블 슈팅

jju71 — Fri, 11 Sep 2026 20:59:32 +0900

트러블 슈팅

2026.09.11

VGG16, RESNET, EfficientNetV2, ConvNext, Swim Transformer를 사용해서 가장 성능이 좋은 모델을 사용하려고 했지만 거의 모든 모델이 성능이 뛰어났음. 한달 프로젝트인데 성능이 좋은 모델로 어떤 악성코드인지 알려주는 것은 단순 분류기능만 있는게 아닐까 하는 의문점에서 시작해 주제에 대해 역추적하기 시작

강사님의 조언으로 원본데이터와 감연된 데이터의 짝을 이뤄 차이점을 비교 후 해결방안을 제안하려 했으나, 원본데이터는 저작권 문제로 잘 공개하지 않고 연구소에 보낸 요청도 거절당함.

So, 하나의 악성코드를 지정해 그 도메인에 대해 공부하고 PE파일 뿐만 아니라 pdf, docs, png, csv 등 다양한 파일에 감염시켜 원본 파일과 비교하기로 결정

하나의 바이러스나 악성코드에 대해서 공부, 정상 파일들을 변형시킨 후 근거를 잡기.
분류보다는 이상 탐지쪽으로 진행
정상 파일을 변형시키는 알고리즘으로 실제 악성코드를 심어서 데이터셋 만들기

단순 이진분류가 아니라 이상탐지로 감염 전과 감염 후의 패턴 분석을 할 예정

GradCam

EfficientNet

ConvNext

악성코드 이미지 데이터셋에서 어떤 위치의 패턴이 악성코드를 가르키는지 확인하고 싶었으나 모델마다 추출하는 특징이 달라 Gradcam에서 일관된 패턴을 감지하지 못함.

2026.09.13

데이터셋

https://practicalsecurityanalytics.com/pe-malware-machine-learning-dataset/?utm_source

PE Malware Machine Learning Dataset

The purpose of this dataset is to provide raw labeled portable executables to security and AI researchers in order to improve cyber security in the industry. Many of the datasets that I have seen (…

practicalsecurityanalytics.com

학습 구조 구성

Byte Embedding

입력 바이트 임배딩: 바이트 하나를 모델이 처리할 숫자 벡터로 변환
출력 바이트 특징 벡터: 모델이 파일의 바이트 패턴을 요약한 결과

Feature Fusion

두 모델의 특징 벡터를 합치는 단계
최종 출력값과 정상•악성 정답의 차이를 계산하고, 그 오차를 줄이도록 두 경로와 분류기의 가중치를 학습

MalConv2 경로 : 파일을 이루는 바이트의 패턴을 읽음
MLP 경로 : 섹션 수, 권한, 엔트로피 같은 PE 구조 정보를 읽음
최종 분류기: 두 경로에서 얻은 정보를 함께 보고 판정

PE Malware이 pair 데이터셋은 아니지만, MalConv2 + PE 구조 MLP 모델에는 페어 데이터가 필요하지 않음.

같은 파일 하나를 두 경로로 분석하고, 그 파일의 정상•악성 라벨을 정답으로 학습할 예정

MalConv2

파일의 원시 바이트 데이터를 직접 분석해 악성코드를 탐지하는 딥러닝 기반의 보안 모델

학습 과정에서 어떤 바이트 패턴이 정상•악성 라벨과 관련이 있는지 찾는다고 이해

임배딩: 바이트마다 '숫자 설명 카드'를 붙이기
합성곱: 작은 범위를 보면서 같은 검사 방식을 반복 적용하는 연산
게이트: 신호의 통과 정도를 조절하는 장치
풀링: 최종 분류기는 일정한 크기의 입력을 받는 편이 편리하므로, 긴 패턴 신호를 요약

MLP(다층 퍼셉트론; Multi-Layer Perceptron)

추출된 특징의 관계를 학습하는 모델

여러 계산층을 연결한 기본적인 신경망

2026.09.14

프로젝트 방향성 피드백받음

PE ➔ .text ➔ section

1차 : PE 헤더 분석

머신러닝
변형 ⭕️
변형 ❌
- 2차: Byte 분석
  - 딥러닝

2026.09.16

2차 Byte 기반 학습의 성능을 비교하고자 EfficientNet과 ResNet도 시도하였으나 두 모델은 이미지 기반이라 MalConv2 모델로 확정

다운로드

https://github.com/FutureComputing4AI/MalConv2

GitHub - FutureComputing4AI/MalConv2: Classifying Sequences of Extreme Length with Constant Memory Applied to Malware Detection

Classifying Sequences of Extreme Length with Constant Memory Applied to Malware Detection - FutureComputing4AI/MalConv2

github.com

기존에 모델을 직접 구현하여 학습을 돌렸을 때 1 Epoch에 약 11시간 소요

논문 읽어본 후 깃허브의 코드를 인용하여 재작성 후 약 1시간에 30% 학습이 완료됨.

아직 학습이 진행 중이지만, MalConv2_GCT의 구조상 첫번째 배치에 상당한 시간이 소요되고 그 이후는 속도가 항샹된다고 하는데 아직까지는 학습 추이를 지켜볼 예정

2026.09.17

배치 사이즈를 자동 조정하게 하면서 학습을 돌려서 성능은 높아졌지만 클래스가 작은 부분의 학습이 모자라서 f1 score가 0.23이 나옴

원인

데이터셋 클래스별 불균형

해결 방안

데이터셋을 더 구해서 학습
- 학습 속도가 매우 느려져서 기한 내 완성할 수 있을지 우려
소수 클래스를 제외한 나머지를 학습 및 분류
- 여러 클래스를 다 포함해서 분류해줄 수 없으니 프로젝트의 퀄리티 저하 우려

팀장회의

전체 파일 구조가 이럴 때 "어느 부분에서 악성코드 확률이 나와서 결과로 이 확률이 나왔다" 정도 소개해주는게 좋지 않겠냐는 방향성을 제시받음

파일: sample.exe
예측 클래스: ○○

위치: 0x1200~0x12FF
영역: .text
관찰 내용: 해당 구간을 가렸을 때 예측 클래스 점수 감소
주변 문자열: ... 해석: 모델의 분류에 영향을 준 구간

우리가 2차 분류에 사용하는 MalConv2 모델로 구현 가능

YOLO_Segmentation

jju71 — Wed, 9 Sep 2026 15:16:56 +0900

1. Segmentation

Segmentation은 컴퓨터 비전에서 이미지나 영상을 픽셀 단위로 분할하여 각 영역이 무엇을 나타내는지 구분하는 기술입니다. 이는 크게 Semantic Segmentation과 Instance Segmentation으로 나뉘는데, Semantic Segmentation은 같은 종류의 객체를 동일한 클래스로 분류하는 반면, Instance Segmentation은 같은 클래스 내에서도 개별 객체를 구분합니다. 이를 통해 의료 영상 분석, 자율주행, 위성 이미지 처리 등 다양한 분야에서 정밀한 객체 인식을 수행할 수 있습니다. Segmentation 모델로는 U-Net, DeepLab, Mask R-CNN 등이 널리 사용됩니다.

icrawler
python3 -m pip install icrawler
파이썬 환경에서 웹상의 이미지를 손쉽게 크롤링할 수 있도록 도와주는 모듈식 이미지 크롤링 프레임워크

2. 스타벅스 데이터셋

COCO JSON

images: 이미지 ID, 파일명, width, height
annotation: 객체의 category, polygon, bbox 등
categories: 클래스 ID와 이름

import json
import random
import shutil
from collections import Counter
from pathlib import Path

import cv2
import matplotlib.pyplot as plt
import numpy as np
import torch
import ultralytics
import yaml

from ultralytics import YOLO

# 경로 설정
PROJECT_ROOT = Path.cwd() # 현재 위치, 현재 폴더
DATA_ROOT = PROJECT_ROOT / "data"
SOURCE_DIR = DATA_ROOT / "starbucks"
YOLO_ROOT = DATA_ROOT / "Starbucks_YOLO"
COCO_JSON = SOURCE_DIR / "instances_default.json"

print("PROJECT_ROOT: ", PROJECT_ROOT)
print("SORUCE_DIR: ", SOURCE_DIR)
print("YOLO_ROOT: ", YOLO_ROOT)
print("COCO_JSON: ", COCO_JSON)

# 파일 읽어서 내용 불러오기
with COCO_JSON.open("r", encoding='utf-8') as f:
    coco_data = json.load(f) 
coco_data

# category ID가 반드시 연속이라는 보장이 없으니까 확인해보려고
categories = sorted(coco_data['categories'], key=lambda x: x['id'])

# 매핑
COCO_ID_TO_YOLO_ID = {
    category['id']: yolo_id for yolo_id, category in enumerate(categories)
}

CLASS_NAMES = [category['name'] for category in categories]

print('이미지 수: ', len(coco_data['images']))
print('Annotation 수: ', len(coco_data['annotations']))
print('클래스: ', CLASS_NAMES)
print('ID 매핑: ', COCO_ID_TO_YOLO_ID)
------------------------------------------------------------------
이미지 수:  612
Annotation 수:  1296
클래스:  ['logo', 'text']
ID 매핑:  {1: 0, 2: 1}

이미지와 Annotation 확인

JOSN에 등록된 이미지가 실제 폴더에 모두 존재하는지 확인
클래스별 annotation 수를 확인하면 특정 클래스가 지나치게 적은지도 확인할 수 있음

image_info_by_id = { image_info['id']: image_info for image_info in coco_data['images'] }

# 빠져있는 것들
missing_images = []

for image_info in coco_data['images']:
    image_path = SOURCE_DIR / image_info['file_name']
    if not image_path.exists():
        missing_images.append(image_info['file_name'])

class_counts = Counter(
    COCO_ID_TO_YOLO_ID[ann['category_id']] for ann in coco_data['annotations']
    if ann['category_id'] in COCO_ID_TO_YOLO_ID)

print("누락 이미지 수: ", len(missing_images))
if missing_images:
    print(missing_images)

for class_id, class_name in enumerate(CLASS_NAMES):
    print(f'{class_id}: {class_name} > {class_counts[class_id]} annotations')
---------------------------------------------------------------
누락 이미지 수:  0
0: logo > 933 annotations
1: text > 363 annotations

COCO Polygon Annotation 시각화

COCO Polygon Annotation의 좌표

[x1, y1, x2, y2, x3, y3, x4, y4, ...]
최소 3개의 점을 연결하여 객체 외곽을 표현

# 이미지 읽어오기
def load_rgb_image(image_path: Path):
    image_bgr = cv2.imread(str(image_path))
    if image_bgr is None:
        raise FileNotFoundError(f'이미지를 읽을 수 없습니다: {image_path}')
    return cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)

# 파일에 대한 객체를 띄우고 좌표 정보를 불러와서 polyline으로 각 점을 연결해서 찍어줌
import cv2

def visualize_coco_annotation(image_id: int):
    image_info = image_info_by_id.get(image_id)
    if image_info is None:
        raise ValueError(f"존재하지 않는 image_id입니다: {image_id}")

    image = load_rgb_image(SOURCE_DIR / image_info['file_name']).copy()

    for ann in coco_data['annotations']:
        if ann['image_id'] != image_id:
            continue

        class_id = COCO_ID_TO_YOLO_ID[ann['category_id']]
        class_name = CLASS_NAMES[class_id]

        for polygon in ann.get("segmentation", []):
            if not isinstance(polygon, list) or len(polygon) < 6: # len(polygon)이 6이면 좌표가 3개밖에 없는 것임
                continue

            points = np.array(polygon, dtype=np.float32).reshape(-1, 2).astype(np.int32) # polygon을 ndarray로 변경, reshape의 -1은 숫자를 2개씩 잡을 때 없으면 너가 자동으로 숫자를 잡아라

            cv2.polylines(image, [points], True, (0, 255, 0), 2)

            x, y = points[0]
            cv2.putText(image, class_name, (int(x), max(20, int(y) - 5)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)

    plt.figure(figsize=(8,6))
    plt.imshow(image)
    plt.axis('off')
    plt.title(f"COCO Annotation - {image_info['file_name']}")
    plt.show()

visualize_coco_annotation(81)

COCO > YOLO Segmentation 변환

YOLO Segmentation 라벨

class_id x1 y1 x2 y2 x3 y3 ...

좌표는 픽셀 값이 아니라 0 ~ 1 사이로 정규화

x_norm = x / image_width
y_norm = y / image_height

# COCO Polyon 객체 세그멘테이션 좌표를 YOLO Segmentation 변환 후 정규화
def coco_polygon_to_yolo_line(class_id, polygon, image_width, image_height):
    if not isinstance(polygon, list) or len(polygon) < 6:
        return None

    if len(polygon) % 2 != 0 :
        return None

    normalized_values = []

    for i in range(0, len(polygon), 2):
        x = polygon[i]
        y = polygon[i + 1]
        x_norm = x / image_width
        y_norm = y / image_height

		# 좌표 정규화
        x_norm = min(max(x_norm, 0.0), 1.0)
        y_norm = min(max(y_norm, 0.0), 1.0)

        normalized_values.extend([x_norm, y_norm])

	# YOLO 포맷 문자열 생성
    coordinates = " ".join(f'{value:6f}' for value in normalized_values)
    return f'{class_id} {coordinates}'

train / val / test 분할

SEED = 2026
TRAIN_RATIO = 0.6
VAL_RATIO = 0.2

random.seed(SEED)

all_images = [image_info for image_info in coco_data['images'] 
            if(SOURCE_DIR / image_info['file_name']).exists()] 

random.shuffle(all_images)
num_images = len(all_images)
num_train = int(num_images * TRAIN_RATIO)
num_val = int(num_images * VAL_RATIO)

# 범위 쪼개기
train_images = all_images[:num_train]
val_images = all_images[num_train:num_train+num_val]
test_iamges = all_images[num_train+num_val:]

print('전체: ', num_images)
print('train: ', len(train_images))
print('val: ', len(val_images))
print('test: ', len(test_iamges))
--------------------------------------------------------
전체:  612
train:  367
val:  122
test:  123

YOLO 폴더 구조 생성

YOLO의 명확한 구조는 이미지와 라벨을 분리하는 방식
예) images / train / starbucks11.jpg > labels / train / starbucks11.txt

def prepare_yolo_split(split_name, split_images):
    image_output_dir = YOLO_ROOT / "images" / split_name
    label_output_dir = YOLO_ROOT / "labels" / split_name

    image_output_dir.mkdir(parents=True, exist_ok=True)
    label_output_dir.mkdir(parents=True, exist_ok=True)

    # 재실행할 때 과거 파일이 남아 섞이는 것을 방지
    for old_file in image_output_dir.iterdir():
        if old_file.is_file():
            old_file.unlink()

    for old_file in label_output_dir.iterdir():
        if old_file.is_file():
            old_file.unlink()

    annotations_by_image = {}

    for ann in coco_data['annotations']:
        annotations_by_image.setdefault(ann['image_id'], []).append(ann)

    for image_info in split_images:
        image_id = image_info['id']
        image_width = image_info['width']
        image_height = image_info['height']
        file_name = image_info['file_name']

        shutil.copy2(SOURCE_DIR / file_name , image_output_dir / file_name) # 왼쪽에서 오른쪽 파일로 복사

        yolo_lines = []

        for ann in annotations_by_image.get(image_id, []):
            coco_category_id = ann['category_id']
            if coco_category_id not in COCO_ID_TO_YOLO_ID:
                continue
            class_id = COCO_ID_TO_YOLO_ID[coco_category_id]
            segmentation = ann.get('segmentation', [])

            if not isinstance(segmentation, list):
                continue

            for polygon in segmentation:
                yolo_line = coco_polygon_to_yolo_line(
                    class_id, polygon, image_width, image_height
                )

                if yolo_line is not None:
                    yolo_lines.append(yolo_line)

        label_path = label_output_dir / f'{Path(file_name).stem}.txt'

        if yolo_lines:
            label_path.write_text("\n".join(yolo_lines), encoding='utf-8')

prepare_yolo_split("train", train_images)
prepare_yolo_split("val", val_images)
prepare_yolo_split("test", test_iamges)
print("COCO > YOLO Segmentation 변경 완료")
---------------------------------------------
COCO > YOLO Segmentation 변경 완료

YOLO txt 라벨 다시 시각화

COCO JSON이 아니라 변환된 YOLO txt를 읽어서 polygon을 그림

# 이미지 > YOLO txt 읽어서 > polygon
def visualize_yolo_label(split_name, image_name):
    image_path = YOLO_ROOT / "images" / split_name / image_name
    label_path = YOLO_ROOT / "labels" / split_name / f"{Path(image_name).stem}.txt"

    image = load_rgb_image(image_path).copy()
    height, width = image.shape[:2]

    if not label_path.exists():
        raise FileNotFoundError(f"라벨이 없습니다: {label_path}")

    for line in label_path.read_text(encoding='utf-8').splitlines():
        values = line.split() # 하나씩 떼어내서 리스트로 집어넣음
        class_id = int(values[0])
        points = np.array(list(map(float, values[1:])), dtype=np.float32).reshape(-1, 2) # ndarray로 가져오면 reshape할 수 있음
        points[:, 0] *= width # txt 파일에서 두개가 짝인데 첫번쨰가 width, width를 곱해주면 원래대로 복원
        points[:, 1] *= height
        points = points.astype(np.int32)

        cv2.polylines(image, [points], True, (0, 255, 0), 2)

        x, y = points[0]
        cv2.putText(image, CLASS_NAMES[class_id], (int(x), max(20, int(y) - 5)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 2)
    
        plt.figure(figsize=(8,6))
        plt.imshow(image)
        plt.axis('off')
        plt.title(f"COCO Annotation - {image_info['file_name']}")
        plt.show()

sample_train_image = train_images[0]['file_name']
print('확인 이미지: ', sample_train_image)

visualize_yolo_label("train", sample_train_image)
--------------------------------------------
확인 이미지:  000064.jpg

YOLO 데이터셋 YAML 생성

0: logo
1: text

yaml_data = {
    "path": str(YOLO_ROOT.resolve()),
    "train": "images/train",
    "val": "images/val",
    "test": "images/test",
    "names": {
        class_id: class_name for class_id, class_name in enumerate(CLASS_NAMES)
    }
}

YAML_PATH = YOLO_ROOT / "starbucks.yaml"

# 파일 만들기
with YAML_PATH.open("w", encoding='utf-8') as f:
    yaml.safe_dump(yaml_data, f, allow_unicode=True, sort_keys=False)

print(YAML_PATH.read_text(encoding="utf-8"))
---------------------------------------------------
path: /Users/juyeong/KDT/11_CV/data/Starbucks_YOLO
train: images/train
val: images/val
test: images/test
names:
  0: logo
  1: text

3. YOLO11 Segmentation 모델

if torch.cuda.is_available():
    DEVICE = torch.device('cuda')
elif torch.backends.mps.is_available():
    DEVICE = torch.device('mps')
elif torch.xpu.is_available():
    DEVICE = torch.device('xpu')
else:
    DEVICE = torch.device('cpu')

print(DEVICE)

# YOLO Segmentation 모델 불러오기
# Ultralytics 라이브러리에서 사전 학습된 YOLO11 Small 크기의 세그멘테이션 모델(yolo11s-seg.pt) 가중치 파일
model = YOLO("yolo11s-seg.pt")
print("Model task: ", model.task)
---------------------------------------------------
Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo11s-seg.pt to 'yolo11s-seg.pt': 100% ━━━━━━━━━━━━ 19.7MB 24.3MB/s 0.8s0.7s<0.1s
Model task:  segment

# YOLO11 Segmentation 모델의 학습(Training)을 실행
train_result = model.train(
    data=str(YAML_PATH),
    epochs = 50,
    imgsz=640,
    batch=4,
    device=DEVICE,
    workers=0,
    seed=SEED,
    patience=20,
    name='starbucks_yolo11s_seg',
    exist_ok=True
)

# best.pt 모델 불러오기
# 일반 pretrained 모델이 아니라 Starbucks 데이터롤 fine-tuning된 모델을 불러옴
best_model = YOLO(str(BEST_MODEL_PATH))
print("Task: ", best_model.task)
print("Classes: ", best_model.names)

Validation 성능 평가

Segmentation 모델은 Box와 Mask 성능을 따로 봄

metrics.box: Bounding Box 기준
metrics.seg: Segmentation Mask 기준

metrics = best_model.val(
    data=str(YAML_PATH),
    split="val",
    imgsz=640,
    device=DEVICE
)

print("Box mAP50: ", metrics.box.map50)
print("Box mAP50-95: ", metrics.box.map)
print("Mask mAP50: ", metrics.seg.map50)
print("Mask mAP50: ", metrics.seg.map)

Segmentation 추론

result.boxes.xyxy: Bounding Box 좌표
result.boxes.cls: class ID
result.boxes.conf: confindence score
result.masks.xy: polygon 좌표
result.masks.data: mask tensor

TEST_IMAGE_DIR = YOLO_ROOT / "images" / "test"

predict_results = best_model.predict(
    source = str(TEST_IMAGE_DIR),
    imgsz = 640,
    conf = 0.30,
    device=DEVICE,
    retina_masks = True,
    save=True,
    name="starbucks_yolo11s_seg_predict",
    exist_ok=True
)

for result in predict_results[:3]: # 결과중 3개만 보겠다
    print("=" * 70)
    print("image:", result.path)

    if result.boxes is not None:
        print("classes    :", result.boxes.cls.cpu().tolist())
        print("confidence :", result.boxes.conf.cpu().tolist())
        print("boxes xyxy :")
        print(result.boxes.xyxy.cpu().numpy())

    if result.masks is not None:
        print("mask tensor shape:", tuple(result.masks.data.shape))
        print("polygon 개수     :", len(result.masks.xy))
    else:
        print("검출된 segmentation mask가 없습니다.")

# 예측한 시각화, 예측해서 polygon을 잘 찍는지
if not predict_results:
    raise RuntimeError("추론 결과가 없습니다.")

result = predict_results[0]

plotted_bgr = result.plot()
plotted_rgb = cv2.cvtColor(
    plotted_bgr,
    cv2.COLOR_BGR2RGB
)

plt.figure(figsize=(10, 8))
plt.imshow(plotted_rgb)
plt.axis("off")
plt.title("YOLO11 Starbucks Instance Segmentation")
plt.show()

YOLO_이안류 CCTV 데이터셋

jju71 — Wed, 9 Sep 2026 15:14:28 +0900

[개별 과제]

1. 이안류 CCTV 데이터셋

AI Hub의 '이안류 CCTV 데이터'는 우리나라 주요 해수욕장(해운대, 송정, 대천, 중문, 낙산)에서 이안류 발생 여부와 위치를 모니터링하기 위해 구축된 인공지능 학습용 데이터셋입니다. 해수욕장 주변에 설치된 CCTV 영상을 이미지로 변환하여, 이안류 발생 여부와 위치를 가시화하는 모델 개발에 활용할 수 있습니다. 이 데이터셋은 이안류 탐지 및 예측 시스템 개발에 필수적인 자료를 제공하며, 해수욕객의 안전을 위한 응용 서비스 구성에 활용될 수 있습니다. 이안류는 해안에서 먼 바다로 빠르게 이동하는 폭이 좁은 바닷물의 흐름으로, 기상 상태가 양호한 경우에도 나타나며, 얕은 곳에 있던 해수욕객을 순식간에 수심이 깊은 먼 바다로 이동시켜 인명사고를 유발할 수 있습니다. 따라서 이러한 데이터셋은 해수욕장 안전 관리 및 이안류 예측 모델 개발에 중요한 역할을 합니다.

https://www.aihub.or.kr/aihubdata/data/view.do?currMenu=115&topMenu=100&aihubDataSe=data&dataSetSn=71297

AI-Hub

데이터셋 다운로드 승인이 완료 된 후 API 다운로드 서비스를 이용하실 수 있습니다. API 다운로드 파일은 분할 압축되어 다운로드 됩니다. 분할 압축 해제를 위해서는 분할 압축 파일들의 병합이

www.aihub.or.kr

2. YOLO 데이터셋 만들기

1. JSON Bounding Box > YOLO Bounding Box

원본 JSON의 drawing에는 객체를 둘러싼 사각형의 점 좌표가 들어있음
YOLO의 일반적인 객체 탐지 레벨 형식
- 클래스ID X센터 Y센터 너비 높이
- 네 개의 좌표를 모두 0~1 사이로 정규화

2. 원본 이미지와 JSON 라벨을 연결한 뒤 train / val / test 폴더로 분류

같은 원본 영상에서 나온 프레임이 train과 test에 동시에 들어가면 성능이 실제보다 높게 보일 수 있음
파일명 앞부분을 그룹으로 사용해 가능한 한 같은 영상 계열이 한 세트에만 들어가도록 분리
- 파일에 따라 각도, 날씨, 위치, 시간대 등이 다르니까
데이터 수가 적으면 YOLO 성능이 낮아질 수 있음(샘플 데이터의 경우)
- 전체 이미지: 360장
- 이얀류 객체가 있는 이미지: 240장
- 배경 이미지: 120장

YOLO는 단순히 이미지를 외우는 것이 아니라 여러 이미지에서 반복적으로 나타나는 시각적 특징을 학습하여 새로운 이미지에서도 객체를 찾아야 함. 단순한 파일 개수가 아니라 서로 다른 상황을 얼마나 다양하게 포함하고 있는지가 중요

CCTV 연속 프레임에서는 무작위로 이미지를 섞어 나누는 방법을 사용하지 않음
- 서로 몇 초 차이인 것의 동일한 프레임이 Train과 Test 동시에 들어가면 모델은 Test 이미지를 처음 보는 것이 아니라, 학습 때 본 장면과 매우 유사한 장면을 다시 보는 것과 비슷해짐(데이터누수)
전체 데이터셋을 확보할 수 있다면 아래 단위로 분리하는 것이 좋음
- CCTV 카메라 각도
- 해수욕장 위치
- 날짜
- 촬영 시간대

3. Detection이 문제 정의에 적합한지 검토

이안류 영역을 Bounding Box로 감싸는 Object Detection 방식은 이안류처럼 형태가 불규칙하고 경계가 명확하지 않은 영역일 경우 Segmentation이 더 적합할 수도 있음