Daddy Makers: 2026

2026년 5월 9일 토요일

헤르메스 에이전트 설치 및 사용방법

이 글은 헤르메스 에이전트 설치 및 사용방법을 간략히 정리한 것이다.

개요

헤르메스는 서버리스로 자체 로컬 컴퓨터에 설치할 수 있는 에이전트이다. 스스로 발전할 수 있도록 구현되어 있어, 지식을 계속 축척하고 이를 재사용할 수 있다.

설치 방법

설치는 리눅스에서 다음과 같이 실행한다.

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

만약 이전에 Open claw 에이전트를 설치했다면, 해당 설정을 임포트할 것인지 다음과 같이 질문한다. 본인은 오픈 클로 설치할때 사용할 LLM모델 등을 미리 설정하였기 때문에, 이 설정 정보를 그대로 가져오기로 했다.

이제 헤르메스 설정이 진행된다. 본인의 경우, 신속 설정 모드를 선택하였다.

대부분 디폴트값으로 설정한다. 그럼, 다음과 같이 마지막에 설정 수정 명령과 함께 에이전트 실행할 지 물어본다. 엔터를 눌러 실행한다.

그럼, 다음과 같은 화면을 볼 수 있을 것이다.

다시 Ctrl+D 를 눌러 헤르메스 에이전트를 빠져나온다.

LLM 모델을 다시 OpenAI Codex로 변경하기 위해 다음 명령을 실행한다.

hermes setup model

화면에서 모델로 OpenAI codex 를 선택하면, 설정 단계를 안내한다. 그대로 따라해 본다.

앞의 코덱스 로그인 때 적색 표시로 코덱스 장치 코드 인증 활성화하라는 메시지가 뜰 수 있다. 다음과 같이 오픈AI의 설정 해당 메뉴를 찾아, 그 옵션을 다음 화면과 같이 활성화한다.

이제 다시 해당 코덱스 링크를 방문하면, 다음과 같은 화면이 나타날 것이다. 헤르메스에서 알려준 코드 를 입력한다.

이제 헤르메스 모델 설정 터미널 화면에서 다음과 같이 로긴되고 모델 설정 옵션 입력을 받을 것이다. 적절한 모델을 설정한다. 그리고 다시 헤르메스 에이전트를 실행한다.

hermes

헤르메스에 다음과 같이 입력한다.

그럼, 해당 모델을 호출해 다음 화면과 같이 인시할 것이다.

헤르메스 에이전트 사용하기
정상적으로 설정되었으니, 헤르메스가 무엇을 할 수 있는 지 다음과 같이 물어보자.

너는 현재 이 컴퓨터에서 무엇을 할 수 있니?

그럼, 다음과 같이 답변할 것이다.

다음 명령을 입력해 본다.

컴퓨터 현재 상태 간단히 점검해줘.

그럼, 헤르메스가 내 컴퓨터 정보를 읽고 다음과 같이 알려줄 것이다.

다음과 같이 현재 웹 정보도 검색 가능한지 확인해 보자.

현재 전쟁과 주식에 관련된 소식을 웹 검색해바

그럼, 헤르메스가 다음과 같이 관련 소식을 검색하기 위한 파이썬 코드를 생성, 실행한 후, 관련 정보를 얻는다. 얻은 정보는 설정된 언어모델을 통해 질문에 대한 답변을 추론해 보여줄 것이다.

바이브 코딩도 간단히 해보자.

코사인 파형이 시간에 따라 흐르는 시뮬레이션을 하는 프로그램 개발해

그럼, 다음과 같이 코딩하고, 프로그램을 헤르메스가 실행된 폴더에 저장한다.

실행하라고 명령을 줘본다.

실행을 했는데, 코사인 파형이 애니메이션되지 않는다. 제대로 파형이 안보이니 문제 원인을 수정해 달라고한다. 그럼, 다음과 같이 코드를 읽고 수정해 줄것이다.

이제 다시 실행해 본다. 그럼, 다음과 같이 프로그램이 실행될 것이다.

이제, 오픈 클로에서 입력햇던 나의 아이덴티티 관련 질문을 해본다.

내 이름이 머지?

다음과 같이 잘 기억하고 있는 것을 알 수 있다.

앞에서 검색했던 뉴스도 한번 더 보여달라고 해보자. 과거에 명령 조사했던 내용을 기억하고 있는 것을 알 수 있다.

이외에 주기적으로 서버 관리용 리포트를 생성하는 등의 일들도 시켜본다.

헤르메스는 여러 터미널에 에이전트를 실행해고, 서로 협업하게도 할 수 있다. 이런 궁금한 것은 헤르메스에게 물어보면 다음과 같이 실행 순서를 알려준다. 그래서 별도 메뉴얼을 공부할 필요가 없다.

참고로 헤르메스가 알려준 tmux 도구는 터미널 멀티플렉서로 터미널 내에서 여러 터미널 세션을 만들어 특정 프로그램들을 실행하고 창을 닫아도 해당 프로그램 실행 세션이 살아있게 해준다. 다음과 같이 tmux를 설치해 달라고 해보자. 그럼 sudo 암호를 달라고 한 후 apt get install 명령으로 설치해준다. 이런 방식으로 헤르메스에 도움을 요청하면 여러 도구와 명령들을 일일히 기억하지 않아도 되어 참 편리하다.

해르메스 사용 중에 축척한 지식은 어디에 저장되는 지도 확인해 보자.

넌 내가 너를 통해 알아낸 지식을 어디에 어떤 방식으로 저장하니?

다음과 같이 메모리 메커니즘을 잘 설명해 줄 것이다.

이외에도 헤르메스가 할 수 있는 것들은 다음과 같다.

- 개발

- 코드 작성/수정, 버그 디버깅, 테스트 자동화, 성능 점검

- 시스템 작업

- 프로세스/포트/메모리/디스크 점검, 로그 분석, 서버 실행

- 데이터 작업

- CSV/JSON 분석, 리포트 요약, 그래프 생성

- 웹 리서치

- 최신 뉴스/기술 문서/가격 정보 검색 후 핵심 요약

- 문서 업무

- 보고서/메일/발표자료 초안 작성, 한국어/영어 다듬기

- 자동화

- 반복 작업 스크립트화, 정기 실행(크론) 구성

- 이미지/음성

- 이미지 생성, 텍스트 음성 변환(TTS)

- 외부 도구 연동

- GitHub, Notion, Google Workspace, 메신저 전송 등(연결된 경우)

- 기타 기능

- 시스템 상태 리포트 자동 생성

- 웹 뉴스 요약 스크립트

- 폴더 정리 자동화 스크립트

이제, ctrl+D를 눌러 헤르메스를 종료한다. 그럼 다음과 같이 이번 헤르메스 사용시 기록한 내용을 세션으로 저장해 보여주고, 사용된 시간, 호출한 도구 개수 등을 요약해 보여줄 것이다.

마무리

최근, 오픈 클로, 헤르메스 에이전트와 같은 멀티 에이전트 시스템이 크게 발전하고 있다. 다양한 모델과 스킬을 입맛에 맞게 사용할 수 있고, 컴퓨터 정리, 개발, 테스트, 서버 모니터링 등 다양한 목적으로 사용할 수 있다. 올라마 같은 로컬 모델 서빙 도구를 설치하면, 클로드나 제미니 같은 상업묭 모델 유료 토큰 사용하지 않고 무료로 로컬에서 실행되는 에이전트를 만들 수 있다. 좀 더 상세한 내용은 레퍼런스를 참고한다.

레퍼런스

NousResearch/hermes-agent: The agent that grows with you

2026년 4월 23일 목요일

개발자 도구 캐시 정리 및 용량 줄이는 방법

이 글은 개발자 도구 캐시 정리 및 용량 줄이는 방법을 간략히 나눔한다.

기본적으로 허깅페이스, PIP 등을 사용하는 개발자로 가정한다.

명령창을 띄워 다음과 같이 실행한다.

pip cache purge

conda clean --all -y

huggingface-cli delete-cache

wandb sync --clean

npm cache clean --force

yarn cache clean

pnpm store prune

docker system prune -a --volumes

docker builder prune -a

docker image prune -a

파이썬에서 다음을 실행한다.

import torch

torch.cuda.empty_cache()

임시 폴더를 삭제한다.

C:\Windows\Temp\

C:\Windows\SoftwareDistribution\Download\

도커 이미지 모두 삭제하려면 다음 실행한다.

docker rmi -f $(docker images -q)

레퍼런스

How to Delete Temporary Files in Windows - GeeksforGeeks

2026년 4월 17일 금요일

오픈클로 같은 에이전틱 시스템 구조 및 동작 메커니즘 분석

이 글은 오픈클로같은 에이전틱 시스템 구조 및 동작 메커니즘 분석해 나눔한다.

레퍼런스

바이브 코딩, 연구, 그리고 아직도 계속되는 환각

이 글은 바이브 코딩, 연구, 그리고 아직도 계속되는 환각 현상에 대한 내용을 정리한다.

클로드 기반 논문 작성 결과 분석(하버드대, Matthew Schwartz 교수)

레퍼런스

추신. 최근 든 생각 정리

최근 AI를 이용하면 다 된다는 사람들이 늘어나고 있다 - 가짜 약사들은 조심

모든걸 AI에 맡겨야 결과물을 만들 수 있다면 본인 가치는 제로에 수렴한다 - 아웃소싱의 AI버전

직접 해보지 않고 말을 옮기는 사람들은 문제를 직관하고 해결할 수 없다 - 빈수레만 요란

무슨 일을 성공했을 때, 본인과 조직 타이틀 중 누가 큰 역할을 했는지 생각해 볼 필요가 있다 - 라벨링

말만 많이 하지 말고 직접 실력, 행동, 결과로 보여줘야 한다 - 성실과 신뢰

본인 역할을 분명히 하되, 스스로 혼란에 빠지진 말자. 보통 동시에 기술세일즈와 연구개발을 함께 할 수는 없다. 전문적인 기술과 경험을 손으로 꾸준히 쌓는 것은 매우 중요하다. 그건 쉽게 달성되지 않고 매우 어려운 것이다. 별것 아니라 애써 말하는 사람일수록 쉽게 대체될 수 있는 상황일 수 있다. 화려한 것에 휘둘리지 말자.

2026년 3월 12일 목요일

멀티모달 LLM (MLLM) 구조, 주요기술 및 한계점

이 글은 멀티모달 LLM (MLLM) 동작 메커니즘을 분석한 글이다. 멀티모달 LLM은 텍스트, 이밎, 오디오, 비디오 같은 여러 종류 데이터 모달리티를 처리하고 이해하도록 설계된 인공지능 모델이다. GPT, 블립-2(VQA 지원), 라바 등이 이들 중 하나이며, 최근 출시한 구글 젬마4도 MLLM이다. 현재 시점에는 구글 제미니 젬마, 알리바바 QWEN, GLM 같은 모델이 많이 활용되고 있다.

MLLM 개념

MLLM의 구조

모델 구조는 다음과 같다.

1. 모달리티 인코더 (Modality Encoder)

모달리티 인코더는 MLLM의 '센서'에 해당하며, 이미지나 오디오와 같은 다양한 형태의 데이터를 LLM이 이해할 수 있는 표현으로 변환하는 장치이다. 이들은 방대한 양의 쌍 데이터(예: 이미지-텍스트)를 통해 사전 학습되어 모델이 서로 다른 정보를 연관시키는 데 기반이 된다. 대표적인 예인 CLIP은 대규모 학습을 통해 시각 데이터와 텍스트 설명을 정렬하는 역할을 수행하는 모델이다. 인코더를 처음부터 학습시키는 대신 사전 학습된 모델을 사용하는 것은 계산 부담을 줄여주는 효율적인 방식이다.

2. 사전 학습된 LLM (Pre-trained LLM)

LLM은 인코딩된 정보를 처리하고 판단하는 시스템의 '두뇌'이다. 웹 텍스트 등 대규모 말뭉치로 미리 학습된 LLM을 사용하는 것은 풍부한 세계 지식과 추론 능력을 즉시 활용할 수 있어 매우 경제적인 선택이다. 이러한 모델들은 복잡한 추론 작업을 수행하기에 이상적인 구조이다. 주로 GPT-3와 같은 인과 디코더 아키텍처를 따르며, LLaMA와 Vicuna 계열은 오픈 소스 기반의 대표적인 모델이다. Qwen과 같은 모델은 다국어를 지원하여 언어적 다재다능함을 갖춘 형태이다.

3. 모달리티 인터페이스 (Modality Interface)

모달리티 인터페이스는 텍스트가 아닌 데이터를 처리하는 인코더를 LLM에 연결하여 원활한 데이터 흐름을 보장하는 구성 요소이다. 이는 크게 '학습 가능한 커넥터'와 '전문가 모델'이라는 두 가지 주요 접근법으로 구분되는 영역이다.

학습 가능한 커넥터: 데이터를 LLM이 처리할 수 있는 형식으로 투사하는 훈련 가능한 모듈이다. BLIP-2처럼 특징을 토큰으로 변환하여 텍스트와 연결하는 토큰 수준 융합 방식이 존재한다. 또한, Flamingo나 CogVLM처럼 교차 주의 계층이나 시각 전문가 모듈을 통해 더 깊은 상호작용을 유도하는 피처 수준 융합 방식도 중요한 기법이다.
전문가 모델: 비텍스트 데이터를 텍스트로 선행 변환한 후 LLM으로 전송하는 독립적인 시스템을 활용하는 방식이다. 모달리티 간의 격차를 단순화할 수 있는 장점이 있으나, 영상이나 이미지의 공간적·시간적 관계를 텍스트로 옮기는 과정에서 정보 손실이 발생할 수 있는 구조이다.

결론적으로 인코더, 사전 학습된 LLM, 그리고 모달리티 인터페이스의 유기적인 결합은 멀티모달 모델 아키텍처의 핵심이다.

멀티모달 기반 트랜스포머 모델 개념

모델 학습 방법

멀티모달 학습 방법은 다른 LLM과 다른 전략을 취하고 있다.

1. CLIP (대조 언어-이미지 사전 학습)

CLIP은 대조 학습(Contrastive Learning)을 통해 이미지와 관련 텍스트를 동일한 선상에 정렬하는 모델이다. 이미지 인코더와 텍스트 인코더를 각각 사용하여 입력을 512차원의 임베딩으로 변환하는 구조이다. 훈련 과정에서 일치하는 쌍의 유사도는 극대화하고, 일치하지 않는 쌍의 유사도는 최소화하여 공유 임베딩 공간을 생성하는 방식이다. 이러한 대규모 데이터 학습을 통해 특정 작업에 대한 추가 훈련 없이도 이미지 분류나 시각적 질문 답변 등에서 뛰어난 제로 샷(Zero-shot) 성능을 발휘하는 것이 특징이다.

2. 플라밍고 (Flamingo)

플라밍고는 CLIP의 비전 인코더에 사전 학습된 언어 모델인 Chinchilla를 결합하여 아키텍처를 확장한 모델이다. 시각 데이터와 텍스트 데이터를 동시에 처리하기 위해 교차 주의(Cross-attention) 계층을 새롭게 도입한 형태이다. 가변 길이의 이미지 임베딩을 언어 모델이 처리 가능한 고정 길이로 변환하는 '인지자 재샘플러(Perceiver Resampler)'가 핵심적인 구성 요소이다. 훈련 시에는 기존 시각 인코더와 언어 모델의 가중치를 고정한 채 교차 주의 계층 등의 학습에만 집중하여 이미지 캡션 및 영상 분석 작업에서 높은 효율을 보여주는 구조이다.

3. 블립-2 (BLIP-2)

BLIP-2는 비전 인코더와 언어 모델을 모두 동결시킨 상태에서 '쿼리 트랜스포머(Q-Former)'의 학습에 집중하여 효율성을 극대화한 모델이다. Q-포머는 이미지 인코더의 시각적 표현과 LLM의 텍스트 표현 사이를 정렬하여 적은 매개변수로도 강력한 이해력을 보장하는 장치이다. 훈련은 이미지-텍스트 표현을 정렬하는 단계와 이미지 기반의 텍스트 설명을 생성하는 단계의 총 2단계로 진행되는 방식이다. 이를 통해 계산 비용을 획기적으로 줄이면서도 시각적 질문 응답 및 분류 분야에서 최첨단 성능을 달성하는 아키텍처이다.

4. 훈련 방식의 의의

이러한 모델들의 훈련 과정은 기존의 거대한 자원을 효율적으로 활용하면서도 모달리티 간의 간극을 좁히는 데 초점을 맞추고 있다. 각 모델은 고유의 인터페이스나 커넥터를 통해 사전 학습된 지식을 보존하면서 새로운 멀티모달 능력을 습득하는 영리한 전략을 취하고 있는 셈이다.

어텐션 모델 메커니즘

한계점

멀티모달 모델은 여러가지 한계점이 있다.

1. 프롬프트 및 데이터 처리의 한계

프롬프트 민감성: 모델의 출력 결과가 프롬프트 디자인에 지나치게 의존하는 경향이 있다. 프롬프트가 학습 데이터의 분포를 벗어날 경우 이해 및 생성 능력이 급격히 저하되며, 이는 모델의 일반적인 이해력에 한계가 있음을 시사하는 지표이다.
텍스트 밀집 이미지 처리의 어려움: 이미지 내에 복잡하고 밀도 높은 텍스트 정보가 포함된 경우 맥락을 완전히 포착하지 못하는 문제가 발생한다. 고정된 쿼리 임베딩 방식이 모델의 유연성을 제한하여 문서 분석과 같은 정밀한 작업에서 오류를 범하기 쉬운 구조이다.
표현 형식의 일관성 부족: 표, 그래프 등 데이터의 형식과 프롬프트 전략에 따라 성능 수준이 가변적인 양상을 보인다. 다양한 데이터 형식 간의 일관성을 유지하는 데 어려움이 있으며, 이는 더 정교한 데이터 표현 기법이 필요함을 의미하는 부분이다.

2. 구조적 및 운용적 한계

모달리티 정렬 문제: 이미지와 텍스트라는 서로 다른 양상의 데이터를 일관되게 정렬하는 것은 매우 어려운 과제이다. 두 모달리티 간의 결합이 완벽하지 않을 경우 맥락 정보가 누락되거나 왜곡되어 전체적인 이해도가 떨어지는 결과로 이어진다.
계산 및 자원 집약도: 여러 모달리티를 통합하는 과정에서 모델의 크기와 복잡도가 필연적으로 증가하게 된다. 이로 인해 학습과 추론에 막대한 처리 능력이 요구되며, 결과적으로 실시간 응용이나 저사양 컴퓨팅 환경에서의 접근성을 저해하는 요소가 된다.

3. 전문성 및 신뢰성 한계

영역 적응력의 제한: 일반적인 작업에서는 우수한 성능을 보이나 의학, 법률과 같은 전문 지식이 필요한 도메인에서는 깊이 있는 추론에 한계를 보인다. 특정 도메인의 데이터 구조와 전문성에 대한 학습이 부족할 경우 해당 분야에서의 활용도가 낮아지는 특성이 있다.
멀티모달 환각(Hallucination) 현상: 입력 데이터에 존재하지 않는 정보를 사실인 것처럼 생성하는 오류가 발생한다. 특히 복잡한 시각 정보를 잘못 해석하여 그릇된 결론을 내리는 환각 현상은 의료나 자율 주행과 같은 고위험 분야에서 치명적인 위험 요인이 된다.

결론적으로 멀티모달 LLM은 시각과 언어의 경계를 허무는 강력한 도구임이 분명하다. 하지만 프롬프트 의존성, 자원 소모, 신뢰성 문제 등 해결해야 할 기술적 난제들이 여전히 산재해 있는 실정이다. 이러한 한계점을 극복하는 것이 향후 차세대 멀티모달 AI 모델이 나아가야 할 핵심적인 방향이다.

레퍼런스: LLM

레퍼런스: 멀티모달

2026년 3월 11일 수요일

오픈클로(Openclaw) 설치 및 사용기

이 글은 Openclaw 설치 및 사용 방법을 간략히 공유한다. 오픈클로는 다양한 스킬(파일 정리, 웹 검색, 코딩, 추론 등등)을 사용 및 확장할 수 있는 AI에이전트 플랫폼으로 오픈소스 프로젝트로 시작되었다. 최근 개발자가 OpenAI팀에 합류했다.

설치 시 주의사항

윈도우에서는 오픈클로 사용해보기 위해 여러번 시도해보았으나 잘 설치 안된다(시간낭비). 그냥 리눅스나 맥북에서 설치하길 바란다. 설치는 다음 링크를 참고한다.

참고로, 본인은 다음 설치 명령을 사용했다.

curl -fsSL https://openclaw.ai/install.sh | bash

본인은 우분투에서 설치했다. 메뉴얼 따라 설치하면, 스킬 설정하는 단계가 나오는 데, 미리 openai, gemini, discord(옵션) 등 외부 api 이용해야 할 스킬들은 미리 api token을 메모했다가 이때 입력하길 바란다.

오픈클로 스킬 설정화면 예시(설치할 각 스킬들 리스트를 보여준다. OpenClaw, makeuseof)

설치 후, 다음 명령을 실행하면, 오픈클로 진단 등이 가능하다.

openclaw doctor # check for config issues

openclaw status # gateway status

openclaw dashboard # open the browser UI

openclaw configure # 오픈클로 재설정

사용하기

모두 설치 및 설정 후 다음 명령을 터미널에 입력한다.

openclaw dashboard

그럼, 오픈클로 데쉬보드 웹사이트를 다음 링크에서 확장할 수 있다.

http://127.0.0.1:18789/chat?session=agent%3Amain%3Amain

데쉬보드의 메뉴 중 채팅 선택 후 채팅창에 프롬프트를 입력해 본다.

처음에는 에이전트와 서로 소개하는 시간을 갖는다(이름, 별명, 취미 등등). 끝나면, 파일을 정리해 달라던가 하는 등의 명령을 입력하면 된다. 스킬들을 연결했으면 해당 스킬을 사용해 명령을 수행할 것이다. 다음처럼 보다시피 파일 정리, 날씨 확인, 코딩 등 다양한 명령들을 잘 처리해 준다.

내 컴퓨터 파일 알아서 정리해줘

코딩해줘

모니터링하기

오픈클로 이용시 지출한 토큰량, 사용 정보 등을 모니터링하는 기능도 다음과 같이 제공된다.

스킬 기능이 잘 구현되면서 에이전트가 더욱 강력해 진 느낌이다. 오픈소스라 오픈클로를 자체 서버에서 서비스할 수 있다. 코드는 공개되어 있으니, 구현이 궁금하다면 분석해 살펴보길 바란다.

2026년 2월 26일 목요일

공학적 해석을 지원하는 DeepXDE 기반 물리AI 모델 PINN 학습 기술

이 글은 DeepXDE 기반 공학적 물리AI 모델 학습 기술 개발 방법을 나눔한다. 특히, 대형 언어 모델(LLM) 기반의 다중 에이전트(Multi-Agent)가 전통적인 유한요소해석(FEM) 도구인 Ansys나 OpenSees 등을 조작하여 구조물의 안전성을 자동 평가하는 기술을 알아본다.

개념도

혼동되는 용어인 물리AI와 피지컬AI에 관련된 깊은 내용은 다음 링크를 참고한다.

NVIDIA 아이작심(Isaac Sim) 기반 대규모 병렬 로보틱스 학습 기술 소개, 설치, 사용 및 피지컬AI모델 학습방법

'Engineer Team'이 수행하는 응답(Pf) 및 내력(Pr) 계산을 기존 FEM 소프트웨어 대신 AI로 처리하여 연산 속도를 기하급수적으로 높일 수 있는 기술이 바로 PINN(Physics-Informed Neural Networks)이다.

PINN의 핵심 개발자 및 창시자

조지 카니아다키스 (George Karniadakis): 브라운 대학교(Brown University) 응용수학과 교수로, PINN이라는 용어와 개념을 학계에 주도적으로 정립한 'PINN의 아버지'로 불린다.
마지아르 라이시(Maziar Raissi) & 파리스 페르디카리스(Paris Perdikaris): 카니아다키스 교수와 함께 2017~2019년에 걸쳐 PINN의 근간이 되는 기념비적인 논문을 공동 저술한 핵심 연구자들이다.
루루: 브라운 대학교 출신으로 현재 펜실베이니아 대학교(UPenn)에 재직 중이며, 가장 유명한 PINN 오픈소스 라이브러리인 'DeepXDE'를 개발하여 기술 대중화에 기여한 인물이다.

유명 오픈소스 및 기술 스택

DeepXDE: 루 루 박사가 개발한 가장 대중적인 오픈소스 라이브러리이다. TensorFlow, PyTorch, JAX 등 다양한 딥러닝 백엔드를 모두 지원하며, 직관적인 API를 제공하여 연구자들 사이에서 1순위로 채택된다.
NVIDIA Modulus: 엔비디아가 개발한 산업용 물리 기반 머신러닝 프레임워크이다. 복잡한 3D 형상과 다중 물리(Multiphysics) 현상을 대규모 GPU 클러스터에서 병렬 처리하는 데 특화되어 있어, 이미지 속 상용 툴(Ansys)의 역할을 직접적으로 대체하는 데 자주 쓰인다.
SciML (NeuralPDE.jl): MIT의 크리스 라카우카스(Chris Rackauckas) 주도 하에 개발된 Julia 언어 기반 생태계이다. 미분 방정식 풀이에 특화된 연산 속도와 효율성을 자랑한다.
PySINDy: 엄밀히 말해 PINN은 아니지만, 측정된 데이터로부터 물리 지배 방정식을 역으로 찾아내는 데이터 기반 물리 모델링 기술 스택으로 함께 자주 활용된다.

프레임워크 사용 예시

대체 모델(Surrogate Model) 연동: 'Analyst Team'의 AutoGen 에이전트가 복잡한 메쉬(Mesh)를 짜고 OpenSees를 돌리는 대신, 사전에 구조 역학(Navier-Cauchy 방정식 등)을 학습한 PINN 모델을 API로 호출한다.
실시간 한계 상태 검토(Limit State Check): 기존 FEM은 구조물 처짐이나 응력 계산에 몇 시간씩 걸릴 수 있지만, PINN은 밀리초(ms) 단위로 Pr과 Pf 값을 도출하여 'Management Team'의 Project Manager 에이전트에게 전달한다.
역해석 및 안전 진단: 센서 데이터(Document/Log)가 주어지면, PINN을 통해 눈에 보이지 않는 구조물 내부의 균열이나 하중 분포를 역으로 추적하여 Safety Manager가 즉각적인 의사결정을 내리도록 돕는다.

DeepXDE 기반 PINN 코딩 예시

다음 패키지를 설치한다.

pip install pyautogen deepxde torch numpy

구조 역학의 가장 기본이 되는 1차원 푸아송 문제(Poisson's equation)를 DeepXDE를 사용하여 푸는 파이썬 코드 예시이다.

import os

os.environ["DDE_BACKEND"] = "pytorch"

import deepxde as dde

import matplotlib.pyplot as plt

import numpy as np

def run_pinn():

# 1. 해석할 공간 정의 (0부터 1까지의 1D 도메인)

geom = dde.geometry.Interval(0, 1)

# 2. 물리 지배 방정식 정의 (d^2y/dx^2 = -2)

# x: 위치 텐서, y: 신경망이 예측한 변위 텐서

def pde(x, y):

dy_xx = dde.grad.hessian(y, x) # y를 x에 대해 2번 미분

return dy_xx + 2.0

# 3. 경계 조건 정의 (양 끝단에서 처짐이 0)

def boundary(x, on_boundary):

return on_boundary

bc = dde.icbc.DirichletBC(geom, lambda x: 0, boundary)

# 4. 학습 데이터셋 구성 (데이터 없이 물리 공식만으로 학습)

# 도메인 내부에 50개의 점, 경계에 2개의 점을 샘플링하여 물리 법칙 검증

data = dde.data.PDE(

geom, pde, bc, num_domain=50, num_boundary=2

)

# 5. 인공신경망 아키텍처 설계 (입력 1개, 50개 노드를 가진 은닉층 3개, 출력 1개)

# 매끄러운 물리 곡선을 표현하기 위해 활성화 함수로 'tanh' 사용

net = dde.nn.FNN([1] + [50] * 3 + [1], "tanh", "Glorot uniform")

# 6. 모델 통합 및 컴파일 (Adam 옵티마이저 적용)

model = dde.Model(data, net)

model.compile("adam", lr=0.001)

print("PINN 학습을 시작함")

# 7. 5000번의 에폭(Epoch) 동안 물리 손실 함수(Loss) 최소화

losshistory, train_state = model.train(iterations=5000)

# 8. 검증 및 결과 시각화

# 0부터 1까지 100개의 테스트 지점 생성

x_test = np.linspace(0, 1, 100).reshape(-1, 1)

# 해석해(진짜 정답) 계산

y_true = x_test * (1 - x_test)

# 학습된 PINN 모델의 예측값 계산

y_pred = model.predict(x_test)

# 중앙 지점(x=0.5) 결과 출력

print("\n=== 학습 결과 ===")

print(f"중앙(x=0.5) 물리 공식 정답: 0.25")

print(f"중앙(x=0.5) PINN 예측 결과: {y_pred[50][0]:.5f}")

# 시각화 차트 생성

plt.figure(figsize=(8, 5))

plt.plot(x_test, y_true, 'r-', linewidth=2, label="Exact Physics Solution")

plt.plot(x_test, y_pred, 'b--', linewidth=2, label="PINN Prediction")

plt.xlabel("Position (x)")

plt.ylabel("Deflection (y)")

plt.title("DeepXDE PINN Result: 1D Equation")

plt.legend()

plt.grid(True)

plt.show()

if __name__ == "__main__":

run_pinn()

실행결과는 다음과 같다.

=== 학습 결과 ===

중앙(x=0.5) 물리 공식 정답: 0.25

중앙(x=0.5) PINN 예측 결과: 0.25030

참고로, 1D Poisson (1차원 푸아송 방정식)은 공학과 물리학에서 가장 뼈대가 되는 아주 유명한 지배 방정식(Governing Equation)이다. 이 푸아송 방정식도 "외부에서 힘(하중, 열, 전기 등)이 가해졌을 때 물체가 어떻게 반응하는가?"를 나타내는 수학적 규칙이다.

1. 수학적 의미: "얼마나 휘어지는가?"

수식으로는 아주 간단하게 다음과 같이 생겼음.

d^2y / dx^2 = f(x)

y: 우리가 알고 싶은 결과값 (예: 기둥이 아래로 처진 깊이)
d^2y / dx^2: y를 위치 x에 대해 두 번 미분한 값. 즉, '곡선이 휘어진 정도(곡률)'를 뜻함.
f(x): 외부에서 가해지는 힘이나 하중임.

"물체가 휘어진 정도는 가해진 하중에 비례한다"는 아주 직관적인 물리 법칙을 수학으로 쓴 것임.

2. 팽팽한 빨랫줄

놀이터에 묶어둔 팽팽한 고무줄이나 빨랫줄을 상상해 본다.

거기에 젖은 수건들을 일정한 간격으로 쭉 널어둠 (이게 바로 균일 하중 f(x) = -2 상황임).
그러면 빨랫줄이 무게 때문에 가운데가 축 처지면서 아름다운 포물선 모양을 그리게 됨.
이때 빨랫줄의 각 지점(x)이 바닥으로 얼마나 처졌는지(y)를 정확히 계산해 내는 것이 바로 1D Poisson 방정식을 푸는 것임.

균일 하중을 받는 1차원 푸아송 방정식의 정답은 완벽한 2차 함수 포물선 형태라는 것을 수학자는 이미 알고 있다. AI에게 데이터(정답지)를 하나도 주지 않고, 오직 "두 번 미분한 값이 -2가 되어야 해"라는 물리 법칙(규칙) 하나만 던져준다.

만약 AI가 이 규칙만 가지고 스스로 학습해서 포물선 모양의 처짐값을 정확히 예측해 낸다면, "이 인공지능이 데이터를 외운 게 아니라 진짜 물리(미분)를 깨우쳤구나!"라고 증명할 수 있기 때문에 푸아송 문제를 PINN에서 많이 활용한다. 그래서, 물리 인공지능(PINN)을 처음 개발할 때 무조건 1순위로 통과해야 하는 기본 관문이 바로 이 1D Poisson 방정식이다. 참고로, 19세기 프랑스의 전설적인 수학자이자 물리학자인 시메옹 드니 포아송(Siméon Denis Poisson, 1781)의 이름을 따서 이 방정식 이름이 붙여졌다.

물리AI 기반 에이전트 개발 방법

이 코드를 AutoGen 기반의 AI 에이전트가 직접 작성하고 실행하도록 만들면, 유한요소분석 소프트웨어의 라이선스나 무거운 연산 과정 없이도 완벽한 자율 구조 검토 인공지능 모델이 가능하다. 'Agent to Agent Communication'을 파이썬의 AutoGen 프레임워크를 이용해 구현하고, 앞서 다룬 PINN(Physics-Informed Neural Networks) 코드를 결합하는 방법을 설명한다.

1. AutoGen 기반 다중 에이전트 시스템 설계

이미지의 워크플로우를 파이썬 코드로 매핑하기 위해 다음과 같이 세 명의 AI 에이전트를 정의한다.

User Proxy (Safety Manager): 목표를 하달하고 코드 실행 권한을 가진 관리자이다.
Engineer Agent (Analyst Team): 구조 해석을 위해 DeepXDE 기반의 PINN 코드를 작성하고 실행 결과를 반환하는 실무자이다.
Project Manager (Reviewer): PINN 해석 결과(최대 처짐량 등)를 건축 구조 기준(Limit State)과 비교하여 최종 안전 여부를 판정한다.

2. AutoGen 및 PINN 결합 파이썬 코드

아래 코드는 에이전트들이 대화를 나누며 스스로 PINN 코드를 작성, 실행, 평가하는 전체 통신 로직이다.

import os

import autogen

from autogen.coding import LocalCommandLineCodeExecutor

def start_interactive_session():

# 1. LLM 환경 설정

# (주의: 실제 구동 시 api_key에 본인의 OpenAI API Key를 문자열로 입력하세요)

llm_config = {

"config_list": [{"model": "gpt-4-turbo", "api_key": ""}],

"temperature": 0.1 # 일관된 논리와 코드 생성을 위해 낮게 설정

}

# 2. 코드가 저장되고 실행될 안전한 작업 폴더 생성

work_dir = "agent_workspace"

os.makedirs(work_dir, exist_ok=True)

# 3. AI 엔지니어 에이전트 생성 (두뇌 역할)

engineer = autogen.AssistantAgent(

name="Engineer",

llm_config=llm_config,

system_message="""당신은 파이썬 기반의 구조 해석 및 PINN(Physics-Informed Neural Network) 최고 전문가이다.

1. 사용자의 질문에 친절하고 명확하게 답하라.

2. 계산이나 모델링이 필요하면 실행 가능한 파이썬 코드를 마크다운 블록(```python ... ```) 안에 작성하라.

3. 코드는 반드시 print() 함수를 통해 결괏값을 터미널에 출력하도록 작성해야 한다.

4. 사용자가 코드 실행 결과를 터미널을 통해 복사해서 넘겨주면, 그 수치가 물리적으로 어떤 의미인지(안전한지, 위험한지 등) 해석해 주어라."""

)

# 4. 사용자 프록시 에이전트 생성 (나 자신 & 코드 실행기 역할)

user_proxy = autogen.UserProxyAgent(

name="User",

human_input_mode="ALWAYS", # ★ 핵심: 매 턴마다 사용자의 입력을 대기하는 채팅 모드

max_consecutive_auto_reply=10,

code_execution_config={

"work_dir": work_dir,

"use_docker": False # 로컬 파이썬 환경에서 직접 코드를 실행하도록 강제

}

)

# 5. CLI 채팅 인터페이스 안내문 출력

print(" AI 구조 엔지니어(Engineer)와 대화하는 인터랙티브 세션입니다.")

print(" - 코드를 실행하려면 아무것도 입력하지 않고 'Enter'만 누르세요.")

print(" - 대화를 완전히 종료하려면 'exit'를 입력하세요.")

# 6. 채팅 워크플로우 시작

# 최초 발화를 빈 메시지로 처리하여, 프로그램이 켜지자마자 사용자의 첫 명령을 기다리게 만듦

user_proxy.initiate_chat(

engineer,

message="안녕하세요. 구조 해석 지원 시스템입니다. 어떤 해석을 도와드릴까요?"

)

if __name__ == "__main__":

start_interactive_session()

3. 에이전트 간 통신(Communication) 실행 흐름

코드를 실행하면 내부적으로 다음과 같은 협업 파이프라인이 작동한다.

1) 작업 지시: Safety Manager가 채팅방에 목표(Task)를 투척한다.

2) 코드 생성: Engineer 에이전트가 앞서 배운 DeepXDE 파이썬 코드를 스스로 작성하여 채팅방에 올린다.

3) 코드 실행: Safety Manager(User Proxy)가 해당 코드를 로컬 환경(pinn_workspace 폴더)에서 실제 실행하고, 처짐량 계산 결과(예: 0.024m)를 채팅방에 다시 반환한다.

4) 결과 검증: Project Manager가 계산된 응답값(P_f)과 허용치(P_r)를 비교한다. "0.024m는 허용 기준 0.05m 이내이므로 안전하다"고 판단한 뒤 `Structurally Adequate` 텍스트를 출력한다.

5) 자동 종료: 종료 조건(Termination Message)이 발동되어 워크플로우가 마무리된다.

실행 결과는 다음과 같다.

User (to Engineer): 길이가 10m, 영률(E)이 200GPa, 단면이차모멘트(I)가 0.0005m^4인 단순 지지보의 중앙에 50kN 하중이 가해질 때의 최대 처짐량을 구하는 파이썬 코드를 작성해 줘. 결과는 반드시 print()로 출력해 줘.

--------------------------------------------------------------------------------

Engineer (to User):

해당 문제는 고전적인 구조역학 문제로, 단순 지지보의 중앙에 집중하중이 작용할 때의 최대 처짐을 계산할 수 있습니다. 이 문제에서는 다음 공식을 사용할 수 있습니다:

\[ \delta_{\text{max}} = \frac{F \cdot L^3}{48 \cdot E \cdot I} \]

여기서:

- $ F $는 중앙에 작용하는 하중 (50 kN)

- $ L $은 보의 길이 (10 m)

- $ E $는 영률 (200 GPa)

- $ I $는 단면이차모멘트 (0.0005 m^4)

이제 이 값을 계산하는 파이썬 코드를 작성하겠습니다.

```python

# 주어진 값

F = 50000 # 하중 (N)

L = 10 # 길이 (m)

E = 200e9 # 영률 (Pa)

이제 이 값을 계산하는 파이썬 코드를 작성하겠습니다.

```python

# 주어진 값

F = 50000 # 하중 (N)

L = 10 # 길이 (m)

E = 200e9 # 영률 (Pa)

```python

# 주어진 값

F = 50000 # 하중 (N)

L = 10 # 길이 (m)

E = 200e9 # 영률 (Pa)

# 주어진 값

F = 50000 # 하중 (N)

L = 10 # 길이 (m)

E = 200e9 # 영률 (Pa)

F = 50000 # 하중 (N)

L = 10 # 길이 (m)

E = 200e9 # 영률 (Pa)

I = 0.0005 # 단면이차모멘트 (m^4)

# 최대 처짐 계산

L = 10 # 길이 (m)

E = 200e9 # 영률 (Pa)

I = 0.0005 # 단면이차모멘트 (m^4)

# 최대 처짐 계산

I = 0.0005 # 단면이차모멘트 (m^4)

# 최대 처짐 계산

delta_max = (F * L**3) / (48 * E * I)

# 결과 출력

print(f"최대 처짐량은 {delta_max:.5f} m 입니다.")

```

4. 구조적 장점

자동화된 Limit State Check: 복잡한 역학 방정식을 사람이 풀거나 상용 툴(Ansys)을 켤 필요 없이, 프롬프트 지시만으로 AI가 해석부터 판정까지 처리한다.
유연한 대처: 만약 PINN 해석 결과가 불안정하게 나오거나 오차가 크면, Project Manager 에이전트가 "학습 에폭(Epoch)을 20000으로 늘려서 다시 계산하라"고 Engineer에게 스스로 피드백을 주며 모델을 튜닝하는 것이 가능하다.

PINN 라이브러리

DeepXDE를 포함해 다른 좋은 SOTA 라이브러리들도 다음과 같이 있다.

DeepXDE (표준 및 교육용 프레임워크)

개발자: 루 루(Lu Lu) 박사와 조지 카니아다키스(George Karniadakis) 교수팀(브라운 대학교, Brown University)이 주도하여 개발하였다.
개발 시기 및 목적: 2019년에 최초 공개되었으며, 복잡한 물리 방정식을 딥러닝으로 풀기 위한 범용적인 라이브러리를 구축하는 것이 목적이다. 입문자들이 수치 해석적 지식 없이도 PINN 모델을 쉽게 구현할 수 있도록 다중 백엔드(TensorFlow, PyTorch, JAX, PaddlePaddle)를 지원하는 추상화된 API를 제공한다.
주요 특징: 연구용으로 가장 널리 쓰이며, 1D/2D/3D의 복잡한 기하학적 영역 정의와 다양한 경계 조건(Dirichlet, Neumann, Robin) 설정을 지원한다.
전체 링크: https://github.com/lululxvi/deepxde

NVIDIA Modulus

개발자: 엔비디아(NVIDIA)의 가속 컴퓨팅 및 AI 연구 팀이 개발하였다. (과거 'SimNet'이라는 이름으로 시작되었다.)
개발 시기 및 목적: 2021년에 정식 출시되었으며, 산업 현장의 대규모 엔지니어링 문제(유체 역학, 열전달, 구조 해석 등)를 해결하기 위해 설계되었다. 전통적인 CAE(Computer-Aided Engineering) 툴을 대체하거나 보완하여 디지털 트윈(Digital Twin)을 실시간으로 구현하는 것이 주된 목적이다.
주요 특징: 엔비디아 GPU 하드웨어에 최적화되어 연산 속도가 압도적이며, 실제 산업용 CAD 데이터(STL 파일 등)를 모델에 직접 입력할 수 있는 기능을 갖추고 있다.
전체 링크: https://github.com/NVIDIA/modulus

NeuralPDE.jl

개발자: 크리스 라카우카스(Chris Rackauckas) 교수와 MIT의 SciML(Scientific Machine Learning) 오픈소스 커뮤니티가 주도하여 개발하였다.
개발 시기 및 목적: 2020년경부터 활발히 개발되었으며, Julia(줄리아) 언어의 고성능 연산 능력을 머신러닝과 결합하는 것이 목적이다. 파이썬의 속도 한계를 극복하고 자동 미분(Automatic Differentiation)의 효율성을 극대화하여 가장 정밀한 물리 해를 구하는 데 집중한다.
주요 특징: 미분 방정식 시스템 전체를 신경망으로 변환하여 풀이하며, 물리 기반 제어(Control) 및 최적화 문제에서 세계 최고 수준의 성능을 보여준다.
전체 링크: https://github.com/SciML/NeuralPDE.jl

FNO (Fourier Neural Operator)

개발자: 리종이(Zongyi Li)와 애니마 아난드쿠마르(Anima Anandkumar) 교수팀(칼텍, Caltech) 및 엔비디아 연구진이 공동 개발하였다.
개발 시기 및 목적: 2020년 말에 발표되었으며, 특정 지점의 해를 구하는 것을 넘어 '입력 함수와 출력 함수 사이의 맵핑(연산자)' 자체를 학습하는 것이 목적이다. 기상 예측이나 나비에-스토크스(Navier-Stokes) 유체 방정식처럼 복잡한 현상을 순식간에 추론하기 위해 개발되었다.
주요 특징: 한 번 학습하면 서로 다른 해상도나 경계 조건에서도 재학습 없이 즉각적으로 결과를 뱉어내며, 기존 수치 해석 대비 최대 1,000배 이상 빠르다.
전체 링크: https://github.com/neuraloperator/fourier_neural_operator

레퍼런스

2026년 2월 24일 화요일

ViT 메커니즘 이해 및 코드 스크래치하기

이 글은 ViT 모델을 스크래치하는 방법을 정리한다.

VLM 개념도

현재 시점(2026.3)에서 최상위 오픈소스 소형 VLM 중 가성비 제일 좋은 것은 gemma-4, qwen vlm 모델이다. 단 gemma-4 는 아무리 작은 모델도 파인튜닝을 위해선는 32GB 이상 VRAM이 필요하다.

개인 로컬 GPU 에서는 SmolVLM, nanoVLM, 팔마 등이 그나마 적절한 VRAM(16GB) 에서 동작한다.

여기서는 VLM의 기반이 되는 ViT모델을 프롬 스크래치해본다. 가장 일반적인 예제인 CIFAR10 이미지 데이터셋을 이용해 VIT를 학습해 보기로 한다. 이 예시는 적은 VRAM(8GB)이내에서 가볍게 학습 방법을 알아보기 위한 목적으로 프롬 스크래치한다. 각 단계별로 주요 부분을 다음과 같이 코딩한다.

모델 하이퍼파라메터 설정

import os, torch
import matplotlib.pyplot as plt
import numpy as np
import torch.nn as nn
from torch.nn import functional as F
import torchvision
import torchvision.transforms as transforms

# 1. 하이퍼파라미터 설정
batch_size = 128        # 범위(32~128),
learning_rate = 1e-4    # Adam 추천값(0.001~0.0001)
epochs = 50             # 범위(10~50) 
device = 'cuda' if torch.cuda.is_available() else 'cpu'

# 모델 아키텍처 사이즈  
img_size = 96
patch_size = 16
n_embd = 256        # 표현력 (n_head=8로 나눠떨어짐)
n_head = 8
num_blks = 6        
emb_dropout = blk_dropout = 0.2   
num_classes = 10    # CIFAR-10이므로 10개 클래스

데이터셋 로딩

# CIFAR-10 원본은 32x32 사이즈지만, 우리가 만든 VLM 구조(96x96)와
# 완벽하게 호환시키기 위해 Resize(96)을 적용.
# 학습 데이터에는 데이터 증강(Augmentation)을 추가하여 일반화 성능 향상
train_transform = transforms.Compose([
    # CIFAR-10(32x32)을 96x96으로 업스케일: LANCZOS 보간으로 경계(edge) 흐림 최소화
    transforms.Resize((img_size, img_size), interpolation=transforms.InterpolationMode.LANCZOS),
    transforms.RandomCrop(img_size, padding=12),     #  패딩 후 랜덤 크롭: 위치 변화에 강건
    transforms.RandomHorizontalFlip(p=0.5),          # 좌우 반전
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),  # 색상 증강
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
    transforms.RandomErasing(p=0.2, scale=(0.02, 0.2)),  # 랜덤 패치 제거: 특정 영역 과의존 방지
])

# 테스트 데이터는 증강 없이 원본 그대로 사용 (동일한 LANCZOS 보간 적용)
test_transform = transforms.Compose([
    transforms.Resize((img_size, img_size), interpolation=transforms.InterpolationMode.LANCZOS),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

print("데이터셋을 다운로드하고 준비합니다...")
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=test_transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# 데이터셋 샘플 몇개 저장
dataiter = iter(trainloader)
images, labels = next(dataiter)
fig, axes = plt.subplots(1, 5, figsize=(15, 3))
for i in range(5):
    img = images[i].numpy()
    img = img * 0.5 + 0.5
    img = np.transpose(img, (1, 2, 0))
    axes[i].imshow(img)
    axes[i].set_title(f"Label: {classes[labels[i]]}")
    axes[i].axis('off')
    
ouptut_fname = "./cifar10_samples.png"
plt.savefig(ouptut_fname)
plt.show()

로딩된 데이터셋 일부 예시는 다음과 같다.

ViT 모델 구조 정의

# 이미지 패치를 임베딩 
class PatchEmbeddings(nn.Module):
    def __init__(self, img_size, patch_size, hidden_dim):
        super().__init__()
        self.conv = nn.Conv2d(in_channels=3, out_channels=hidden_dim, kernel_size=patch_size, stride=patch_size)

    def forward(self, X):
        X = self.conv(X)            # shape = (B, hidden_dim, H/patch_size, W/patch_size). (128, 256, 6, 6)
        X = X.flatten(2)            # flatten(2) means flattening the last two dimensions. shape = (128, 256, 36)
        X = X.transpose(1, 2)       # shape = (128, 36, 256)
        return X

patch_emb = PatchEmbeddings(img_size, patch_size, n_embd).to(device)
print("입력 이미지 크기:", images.shape)
print("패치 임베딩 출력 크기:", patch_emb.forward(images.to(device)).shape)

ViT는 트랜스포머 구조를 그대로 활용한다. 이를 아래 ViT와 연계해 사용한다.

class ViT(nn.Module): # 비전 트랜스포머 모델
    def __init__(self, img_size, patch_size, num_hiddens, num_heads, num_blks, emb_dropout, blk_dropout, num_classes):
        super().__init__()
        self.patch_embedding = PatchEmbeddings(img_size, patch_size, num_hiddens)   # 이미지 패치를 임베딩 벡터로 변환
        self.cls_token = nn.Parameter(torch.zeros(1, 1, num_hiddens))               # 클래스 토큰 초기화 (학습 가능한 파라미터)
        num_patches = (img_size // patch_size) ** 2
        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, num_hiddens))     # 위치 임베딩 초기화 (학습 가능한 파라미터)
        self.dropout = nn.Dropout(emb_dropout)                                      
        
        self.blocks = nn.ModuleList([Block(num_hiddens, num_heads, blk_dropout, is_decoder=False) for _ in range(num_blks)]) # 트랜스포머 블록 여러 개 쌓기
        self.layer_norm = nn.LayerNorm(num_hiddens) # 최종 레이어 정규화
        self.classifier = nn.Linear(num_hiddens, num_classes) # 분류기(클래스 토큰을 최종적으로 클래스 확률로 변환)

    def forward(self, X):
        x = self.patch_embedding(X)     # shape = (B, num_patches, num_hiddens) from patch embedding. (128, 3, 96, 96) -> (128, 36, 256)
        cls_tokens = self.cls_token.expand(x.shape[0], -1, -1)  # shape = (B, 1, 256)
        x = torch.cat((cls_tokens, x), dim=1)                   # shape = (B, num_patches + 1, num_hiddens). (128, 37, 256) 
        x += self.pos_embedding     # 위치 임베딩 추가. 초기값은 랜덤이지만 학습을 통해 최적화됨. (128, 37, 256)
        x = self.dropout(x)
        
        for block in self.blocks:
            x = block(x)
            
        cls_output = self.layer_norm(x[:, 0])   # 클래스 토큰의 최종 표현을 추출 (shape = (B, num_hiddens). (128, 256))
        logits = self.classifier(cls_output)    # 클래스 토큰을 최종적으로 클래스 확률로 변환 (shape = (B, num_classes). (128, 10))
        return logits  

모델 학습

print(f"1. 모델 초기화 (디바이스: {device})")
model = ViT(img_size, patch_size, n_embd, n_head, num_blks, emb_dropout, blk_dropout, num_classes).to(device)
# Adam에 weight decay 추가 (일반화 성능 향상)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss() 

# [개선] CosineAnnealingLR: 코사인 곡선으로 학습률 감소 → ReduceLROnPlateau 대비 안정적 수렴
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)

print("2. CIFAR-10 학습 시작")
best_val_loss = float('inf')
patience = 10  # [개선] 3→10: 코사인 스케줄러 환경에서 일시적 val loss 증가 허용
patience_counter = 0
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        # 100 미니배치마다 로그 출력
        if i % 100 == 99:    
            print(f"[Epoch {epoch + 1}, Batch {i + 1}] Loss: {running_loss / 100:.3f}")
            running_loss = 0.0

    # validation loss 계산 (테스트 데이터 사용)
    model.eval()
    val_loss = 0.0
    with torch.no_grad():
        for val_inputs, val_labels in testloader:
            val_inputs, val_labels = val_inputs.to(device), val_labels.to(device)
            val_outputs = model(val_inputs)
            val_loss += criterion(val_outputs, val_labels).item()
    val_loss /= len(testloader)
    print(f"[Epoch {epoch + 1}] Validation Loss: {val_loss:.4f}")
    
    # CosineAnnealingLR 스케줄러 업데이트 (매 epoch 호출)
    scheduler.step()

    # early stopping
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        patience_counter = 0
        # 모델 저장 (optional)
        torch.save(model.state_dict(), 'best_vit_model.pth')
    else:
        patience_counter += 1
        if patience_counter >= patience:
            print("Early stopping triggered.")
            break