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

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

기본적으로 허깅페이스, 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()

앱 개발시에는 다음을 실행한다.

flutter clean 

cd android 

.\gradlew clean

# 다운로드된 의존성·빌드 캐시

Remove-Item -Recurse -Force "$env:USERPROFILE\.gradle\caches"

# 구버전 Gradle 배포판들 (버전별로 수백 MB씩 쌓임)

Remove-Item -Recurse -Force "$env:USERPROFILE\.gradle\wrapper\dists"

# 좀비 데몬 로그

Remove-Item -Recurse -Force "$env:USERPROFILE\.gradle\daemon"

flutter pub cache clean

dart pub cache repair 

 

Remove-Item -Recurse -Force "$env:USERPROFILE\.android\avd\*.avd\snapshots"

Remove-Item -Recurse -Force "$env:LOCALAPPDATA\Google\AndroidStudio*\caches"

Write-Host "Gradle caches..." 

Remove-Item -Recurse -Force "$env:USERPROFILE\.gradle\caches" -ErrorAction SilentlyContinue

Remove-Item -Recurse -Force "$env:USERPROFILE\.gradle\daemon" -ErrorAction SilentlyContinue

Write-Host "Pub cache..."

flutter pub cache clean

  

임시 폴더를 삭제한다.

C:\Windows\Temp\

C:\Windows\SoftwareDistribution\Download\

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

docker rmi -f $(docker images -q)

다음과 같이 배치파일을 작성해 한번에 처리할 수도 있다.

@echo off

chcp 65001 >nul

cls

:: 1. 개발 패키지 및 AI 캐시 정리

where pip >nul 2>&1 && echo [*] pip cache... && pip cache purge >nul 2>&1

where conda >nul 2>&1 && echo [*] conda cache... && call conda clean --all --yes >nul 2>&1

where npm >nul 2>&1 && echo [*] npm cache... && call npm cache clean --force >nul 2>&1

where huggingface-cli >nul 2>&1 && echo [*] Hugging Face cli cache... && huggingface-cli delete-cache --quiet >nul 2>&1

if exist "C:\Users\KSW\.cache\huggingface\hub" (

    echo [*] Cleaning Hugging Face incomplete downloads...

    del /f /s /q "C:\Users\KSW\.cache\huggingface\hub\version.txt" >nul 2>&1

)

:: 2. 도커(Docker) 캐시 및 끊어진 이미지 정리 

where docker >nul 2>&1 && echo [*] Docker system pruning... && docker system prune -f >nul 2>&1

:: 3. 임시 폴더(Temp) 파일 정리

echo [*] Cleaning Temp folders...

if exist "C:\Users\KSW\AppData\Local\Temp" (

    del /f /s /q "C:\Users\KSW\AppData\Local\Temp\*.*" >nul 2>&1

    for /d %%p in ("C:\Users\KSW\AppData\Local\Temp\*") do rmdir /s /q "%%p" >nul 2>&1

)

if exist "%SystemRoot%\Temp" (

    del /f /s /q "%SystemRoot%\Temp\*.*" >nul 2>&1

    for /d %%p in ("%SystemRoot%\Temp\*") do rmdir /s /q "%%p" >nul 2>&1

)

if exist "%SystemRoot%\Prefetch" (

    del /f /s /q "%SystemRoot%\Prefetch\*.*" >nul 2>&1

)

echo [+] All caches cleared.

timeout /t 3

레퍼런스

• How to Delete Temporary Files in Windows - GeeksforGeeks

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

이 글은 오픈클로같은 에이전틱 시스템 구조 및 동작 메커니즘 분석해 나눔한다. 자율형 AI 에이전트 프레임워크인 오픈클로(OpenClaw)는 사용자의 로컬 컴퓨터에서 백그라운드 데몬으로 상시 구동되며, 메신저 인프라를 UI로 삼아 파일 시스템, 웹 브라우저, OS 셸 명령 등을 직접 제어하는 아키텍처를 가지고 있다.

오픈클로 설치 및 사용법은 다음 링크를 참고한다.

• Daddy Makers: 오픈클로(Openclaw) 설치 및 사용기

오픈클로의 핵심 객체 지향 컴포넌트 구조와 시퀀스는 다음과 같다.

아키텍처 구조

오픈클로는 중앙의 관리 데몬이 허브 역할을 수행하며, 외부 메신저 및 대형언어모델(LLM) 인프라, 그리고 로컬의 기술(Skills) 디렉토리를 유기적으로 연결하는 구조를 취한다.

• GatewayDaemon (게이트웨이 데몬): 시스템의 최상위 실행 주체이다. OS의 LaunchAgent나 Linux의 systemd와 결합하여 24시간 백그라운드에서 상시 구동되는 데몬 프로세스 역할을 한다.
• MessagingBridge (메신저 브릿지): Telegram, WhatsApp, Discord 등 외부 커뮤니케이션 채널과 소통하기 위한 추상화 인터페이스이다. 사용자로부터 전달받은 명령을 입력 데이터로 파싱하여 내부 시스템에 넘겨준다.
• AgentCore (에이전트 코어): 인컨텍스트 메모리(In-context Memory)와 가드레일 검증 로직을 포함하는 핵심 클래스이다. LLM의 판단 결과에 따라 루프를 지속할지, 마칠지 결정한다.
• LLMProvider (LLM 공급자): Anthropic Claude, DeepSeek, OpenAI 또는 로컬의 Ollama 서버와 통신하는 추론 레이어이다. 자연어 명령과 가용한 툴 목록을 입력받아 정형화된 툴 호출(Tool Call) 응답을 반환한다.
• SkillManager (스킬 매니저): 오픈클로의 확장 모델인 'Skills'를 스캔하고 관리한다. 워크스페이스 내 SKILL.md 파일에 기록된 YAML 메타데이터와 실행 스크립트를 로드하여 실제 OS 자원(셸, 브라우저 등)을 구동한다.
• LocalWorkspace (로컬 워크스페이스): ~/.openclaw 경로를 기반으로 자율 작업 목록인 HEARTBEAT.md, 대화 기록, 스킬 소스코드를 보관하는 물리적 로컬 저장소 공간이다.

시퀀스 구조

오픈클로는 사용자의 직접적인 메신저 입력뿐만 아니라, 정해진 시간 주기(Heartbeat)마다 HEARTBEAT.md를 스캔하여 스스로 할 일을 판단하고 추론-실행 루프(ReAct Loop)를 구동한다.

1. 루프 진입 단계: 실행 경로는 두 가지로 나뉜다. 첫째는 데몬이 주기적으로 HEARTBEAT.md 파일을 열어 자율적으로 태스크를 발굴하는 경로이며, 둘째는 메신저 인터페이스를 통해 사용자의 다이렉트 명령이 인입되는 경로이다.

2. ReAct 추론 단계: 에이전트 코어가 현재의 상태값과 파일 내부의 컨텍스트, 그리고 스킬 매니저가 확보한 사용 가능 도구 명세를 취합하여 LLM 레이어로 전송한다. LLM은 이를 분석하여 다음에 실행할 구체적인 행동(도구 종류 및 파라미터)을 결정한다.

3. 가드레일 및 도구 실행 단계: 에이전트 코어는 도구 실행 전 내부 보안 정책을 검증한다. 검증을 통과하면 스킬 매니저가 파일 시스템 접근이나 외부 웹 브라우징, 내부 셸 스크립트 실행과 같은 고권한 작업을 로컬 컴퓨터 내부에서 직접 수행한다.

4. 상태 동기화 및 종결 단계: 도구의 수행 결과 데이터는 다시 컨텍스트 메모리에 병합되어 다음 루프의 판단 근거로 활용되며, 동시에 로컬 워크스페이스에 Markdown 파일 형태로 실시간 저장된다. 더 이상 추가 행동이 필요 없다고 판단되면 루프가 종료되고 결과물이 사용자의 메신저 창으로 전송된다.

하네스 엔지니어링과 주요 md 문서 역할

오픈클로(OpenClaw)와 같은 자율형 AI 에이전트 프레임워크에서 하네스 엔지니어링(Harness Engineering)은 에이전트가 호스트 OS 자원을 크게 소모하지 않고, 안전하고 일관되게 임무를 수행하는지 격리, 테스트, 평가하기 위한 환경을 구축하는 작업이다. 하네스 시스템이 에이전트를 통제하고 검증하기 위해 워크스페이스에 추가로 요구하는 핵심 마크다운 파일들의 역할과 구체적인 작성 예시는 다음과 같다.

1. FIXTURE.md (테스트 환경 및 데이터 주입 정의서)

테스트가 시작되기 전, 하네스 시스템이 에이전트의 로컬 워크스페이스나 격리된 가상 OS 환경에 강제로 주입해야 하는 사전 조건(Pre-conditions)과 모킹(Mock) 데이터를 선언하는 문서이다. 에이전트가 외부 API나 실제 가동 중인 시스템을 오염시키지 않도록 가상의 샌드박스 상태를 설계하는 뼈대가 된다.

markdown

---

targetSkill: github-operator

environmentType: docker-isolated

timeoutSeconds: 120

본 문서는 github-operator 스킬을 검증하기 위해 하네스가 사전에 구성해야 하는 로컬 환경 상태를 정의한다.

1. 가상 파일 시스템 픽스처

하네스는 에이전트 구동 전 ~/.openclaw/sandbox/repo 경로를 생성하고 아래 구조로 더미 파일을 배치한다.

- README.md: "This is a mock repository for agent testing." 내용 기입

- src/main.py: 구문 에러가 포함된 임의의 파이썬 코드 주입

2. CLI 도구 모킹 (Mocking)

실제 GitHub 서버에 부하를 주거나 인증 오류가 나는 것을 방지하기 위해 gh 명령어 인터셉터를 가동한다.

- 사용자가 gh issue list 실행 시, 아래의 하드코딩된 JSON 데이터를 반환하도록 셸 환경 변수를 조작한다.

json

[

  {"number": 101, "title": "Fix bug in main.py", "state": "open"},

  {"number": 102, "title": "Update documentation", "state": "open"}

]

3. 초기 환경 변수

GITHUB_TOKEN: mock_token_xyz123으로 강제 바인딩한다.

DEBUG_MODE: true로 설정하여 에이전트의 모든 내부 서브프로세스 로그를 하네스 덤프 파일에 기록한다.

2. EVAL.md (에이전트 능력 평가 및 검증 기준서)

에이전트가 ReAct 루프를 종료한 후, 부여된 태스크를 올바르게 완수했는지 하네스 검증기(Evaluator)가 자동으로 판정하는 단언(Assertion) 규칙과 메트릭을 정하는 문서이다. LLM 응답의 정형성뿐만 아니라 실행 후 최종 변경된 OS 파일 시스템이나 데이터베이스의 상태를 추적하여 합격/불합격을 결정한다.

evaluatorType: rule-and-llm-hybrid

metrics:

  - correctness

  - tokenEfficiency

  - safetyCompliance

에이전트의 실행 리포트와 최종 워크스페이스 상태가 아래 Assertion 조건을 모두 통과해야 최종 SUCCESS 판정을 내린다.

1. 하드 조건 (Hard Assertions)

하네스 검증기는 아래 3가지 물리적 상태 변화를 체크하며, 하나라도 실패 시 즉시 불합격 처리한다.

- [ ] 결과 파일 존재 여부: ~/.openclaw/sandbox/repo/patch.diff 파일이 반드시 생성되어 있어야 한다.

- [ ] 구문 오류 해결 여부: 수정된 src/main.py 파일은 python3 -m py_compile 명령을 통과해야 한다.

- [ ] 프로세스 잔존 금지: 에이전트가 좀비 프로세스를 남기지 않고 백그라운드 셸을 정상 종료(exit 0)했어야 한다.

2. 소프트 조건 (Soft Assertions / LLM 판정)

하네스는 판정용 LLM을 별도 구동하여 사용자의 메신저로 최종 발송된 텍스트의 품질을 검사한다.

- 사용자가 불쾌감을 느낄 수 있는 공격적 단어가 포함되지 않아야 한다.

- 결과 보고 문장이 '이다'체 명세 스타일에 부합하는지 문체 일치율을 평가한다. (임계치 90% 이상)

3. GUARDRAIL.md (하네스 안전 제약 및 권한 경계 정의서)

하네스가 에이전트를 모니터링하는 과정에서 절대 허용하지 않을 금지 행동(DenyList)과 위험 감지 규칙을 정의하는 보안 통제 문서이다. 에이전트의 오작동이나 프롬프트 인젝션 공격으로 인해 호스트 PC의 핵심 자원이 탈취되거나 파괴되는 현상을 시스템 콜(System Call) 및 네트워크 레벨에서 실시간 차단하는 실질적인 방화벽 역할을 수행한다.

enforcement: strict-block

alertChannel: admin-telegram

에이전트 및 하위 스킬 스크립트가 실행되는 도중 아래 규칙을 위반하는 징후가 포착되면, 하네스는 즉시 해당 에이전트 프로세스를 강제 종료(kill -9)한다.

1. 파일 시스템 접근 금지 경로 (Blacklisted Paths)

에이전트는 지정된 샌드박스 경로 외에 아래 시스템 영역에 대한 쓰기(write) 및 삭제(unlink) 명령을 내릴 수 없다.

- /etc// (시스템 설정 영역)

- ~/.ssh// (인증 키 파일 영역)

- ~/.openclaw/system// (오픈클로 코어 소스코드 영역)

2. 블랙리스트 명령어 패턴

셸 실행 도중 아래 정규식 패턴과 매칭되는 파괴적 명령어가 감지되면 실행 전 차단한다.

- rm\s+-rf\s+/

- chmod\s+-R\s+777

- killall\s+ (하네스 자체 프로세스 저격 방지)

3. 네트워크 유출 통제

- 대형 언어 모델 공급자 API 주소(api.anthropic.com, api.openai.com)를 제외한 임의의 외부 IP로의 Raw 소켓(Socket) 아웃바운드 연결을 원천 차단한다. 픽스처에 등록되지 않은 외부 URL로 데이터를 유출하려는 시도는 프롬프트 바이패스 공격으로 간주한다.

4. 하네스 엔지니어링 문서의 유기적 흐름 요약

• FIXTURE.md가 안전한 가상 실험실 환경과 가짜 데이터를 에이전트에게 주입한다.
• 에이전트는 제공된 환경 안에서 SKILL.md와 HEARTBEAT.md 지침에 따라 임무를 수행한다.
• GUARDRAIL.md는 에이전트가 임무를 수행하는 실시간 런타임 과정 전체를 감시하고 위험을 차단한다.
• 에이전트가 멈추면 EVAL.md가 최종 상태를 검사하여 이 에이전트 시스템이 안전하고 유능한지 최종 판정한다.

이 4개 레이어의 마크다운 명세가 유기적으로 맞물리는 구조를 구축하는 것이 에이전트 하네스 엔지니어링의 원리이다.

마무리

오픈클로(OpenClaw)의 핵심 아키텍처와 실행 시퀀스, 그리고 자율 구동 및 통제를 위한 하네스 엔지니어링 명세 체계까지 전체적인 구조를 분석하였다.

• HEARTBEAT.md와 SKILL.md를 통해 에이전트는 사용자의 실시간 개입 없이도 안전하게 로컬 도구를 조합하고 스스로 태스크를 발굴하여 움직이는 실행력을 갖추게 된다.
• FIXTURE.md, GUARDRAIL.md, EVAL.md로 구성된 하네스 환경은 자율형 에이전트가 프롬프트 주입 공격을 받거나 오작동하여 호스트 OS 시스템을 파괴하지 않도록 묶어두는 시스템적 방화벽 역할을 수행한다.

결국 완성도 높은 AI 에이전트 서비스를 구축한다는 것은 단순히 똑똑한 거대언어모델(LLM)을 선택하는 레이어에 그치지 않는다. 에이전트가 움직일 아키텍처의 뼈대를 견고히 다지고, 실행 환경과 검증 단계를 문서 형태로 표준화(Specification as Code)하여 시스템적으로 통제하는 것이 하네스 엔지니어링의 원칙이다.

이러한 설계 패러다임은 향후 더 복잡한 로컬 자동화와 고권한 작업을 수행하는 자율형 에이전트 소프트웨어를 안전하게 빌드하고 확장할 때 좋은 통찰을 준다.

레퍼런스

• openclaw/openclaw: Your own personal AI assistant. Any OS. Any Platform. The lobster way
• huggingface/smolagents: smolagents: a barebones library for agents that think in code
• dusty-nv/NanoLLM: Optimized local inference for LLMs with HuggingFace-like APIs for quantization, vision/language models, multimodal agents, speech, vector DB, and RAG.
• agno-agi/agno: Build, run, manage agentic software at scale.

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

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

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

레퍼런스

• Matthew Schwartz's detailed retrospective on writing a paper entirely with AI : r/Physics
• Vibe physics: The AI grad student \ Anthropic
• SWE-bench Leaderboards

추신. 최근 든 생각 정리

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

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

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

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

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

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

멀티모달 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

• Multimodal LLMs: Learn How MLLMs Blend Vision & Language
• Large Language Model (LLM) Tutorial - GeeksforGeeks
• Attention Mechanism in ML - GeeksforGeeks
• Transfer Learning of Multimodal Models · Hugging Face
• Introduction · Hugging Face
• Data Science, Seoul National University

레퍼런스: 멀티모달

• What is a Large Language Model (LLM) - GeeksforGeeks
• What are Language Models in NLP? - GeeksforGeeks
• Transfer Learning of Multimodal Models · Hugging Face
• Qwen 2.5-VL 7B Fine-Tuning Guide for Segmentation
• Equipment Failure Prediction using Machine Learning Models | by Sankar | Medium
• Hugging Face TRL을 적용한 멀티모달 모델 또는 VLM을 미세 조정하는 방법

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

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

오픈클로와 유사한 헤르메스 에이전트 설치 및 사용법은 다음을 참고한다.

• Daddy Makers: 헤르메스 에이전트 개발배경, 설치 및 사용방법
• Daddy Makers: 오픈클로 같은 에이전틱 시스템 구조 및 동작 메커니즘 분석

설치 시 주의사항

윈도우에서는 오픈클로 사용해보기 위해 여러번 시도해보았으나 잘 설치 안된다(시간낭비). 그냥 우분투, 리눅스 PC 나 애플 미니, 맥북, NVIDIA DGX 스파크에서 설치하길 바란다. 

요즘 히트하고 있는 애플 맥 미니, NVIDIA DGX 스파크

설치는 다음 링크를 참고한다.

• Install - OpenClaw
• openclaw/openclaw: Your own personal AI assistant. Any OS. Any Platform. The lobster way
• https://docs.openclaw.ai/channels/discord

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

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

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

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

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

코딩해줘

모니터링하기

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

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

공학적 해석을 지원하는 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)

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

레퍼런스

• Large language model-empowered next-generation computer-aided engineering - ScienceDirect
• Automating Structural Engineering Workflows with Large Language Model Agents
• DL-VLM: A Dynamic Lightweight Vision-Language Model for Bridge Health Diagnosis
• dataset-ninja/codebrim: CODEBRIM: COncrete DEfect BRidge IMage Dataset
• "SDNET2018: A concrete crack image dataset for machine learning applica" by Marc Maguire, Sattar Dorafshan et al.
• PrismaX/PhysUniBench · Datasets at Hugging Face
• DelosLiang/masse: Automating Structural Engineering Workflows with Large Language Model Agents
• CODEBRIM: COncrete DEfect BRidge IMage Dataset
• zhuminjie/OpenSeesPy: OpenSeesPy versions, doc, and pip

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

학습 결과

학습된 결과는 다음과 같다. 

1. 모델 초기화 (디바이스: cuda)

2. CIFAR-10 학습 시작

[Epoch 1, Batch 100] Loss: 2.161

[Epoch 1, Batch 200] Loss: 2.026

[Epoch 1, Batch 300] Loss: 1.967

[Epoch 1] Validation Loss: 1.8028

[Epoch 2, Batch 100] Loss: 1.856

[Epoch 2, Batch 200] Loss: 1.797

[Epoch 2, Batch 300] Loss: 1.745

유사하게 정답을 맞추는 것을 확인할 수 있다. 자세한 코드 구현은 다음 링크에서 확인할 수 있다. 

• multimodal_ai_tutorial/4_vit/2_vit_scratch_cifar10.ipynb

VLM 파인튜닝 레퍼런스

• Fine-Tuning Gemma 3 VLM using QLoRA for LaTeX-OCR Dataset
• Vision-language-models-VLM: vision language models finetuning notebooks (Medgemma - paligemma - florence .....)
• How to Fine-Tune Qwen3-VL on Your Own Dataset | Datature Blog (over 32g vram)
• VLM-LORA finetuning using OpenCLIP Workload — AMD Enterprise AI for robotics
• The Definitive Guide to Fine-Tuning a Vision-Language Model on a Single GPU (with code) with DORA | by Pavan Kunchala | Medium
• LoRA in Vision Language Models: Efficient Fine-tuning with LLaVA | by Phrugsa Limbunlom (Gift) | Artificial Intelligence in Plain English
• nanoVLM: The simplest repository to train your VLM in pure PyTorch
• SmolVLM - small yet mighty Vision Language Model

VLM 스크래치 레퍼런스

• Training a Vision Language Model from scratch (VLM multi-modal) | by Saptarshi MT | Medium
• Implementation of Vision language models (VLM) from scratch: A Technical Deep Dive. | by Achraf Abbaoui | Medium
• Wiring the Multimodal Mind: Building a Vision Language Model (VLM) from Scratch - Part 1 | by Priyanthan Govindaraj | Medium
• Vidit-Ostwal/VLM-from-scratch: This is majorly for my own learning purpose.
• Building a Nano Vision-Language Model from Scratch
• nipunbatra/vlm-from-scratch
• Building PaliGemma VLM From Scratch using Pytorch | by Shanmuka Sadhu | Jan, 2026 | Medium

오픈소스 라이브러리

• seemore: From scratch implementation of a vision language model in pure PyTorch

ViT 개념 설명 레퍼런스

• Vision Transformer (ViT) from Scratch
• Vision Language Model from scratch in Pytorch #vlm - Qiita
• ViT Scratch Implementation - PyTorch
• Building Vision Transformers (ViT) from Scratch | by Maninder Singh | Medium
• 今井美樹 彼女と TIP ON DUO 歌詞 - 歌ネット
• Building a Vision Transformer from Scratch in PyTorch - GeeksforGeeks
• Training a Vision Transformer from Scratch on CIFAR-10:No Pre-training, No Problem | by Akshay Gokhale | Medium
• Vision Transformer For CIFAR-10