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

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

레퍼런스

• 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

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

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

설치 시 주의사항

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

• 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

가우시안 스플리터의 한계와 공간모델 개발

오토데스크나 제조업에서 요구하는 진정한 '공간 지능'과 '파라메트릭 CAD'를 구현하려면, AI가 단순한 점과 면(Mesh)의 집합이 아닌 B-rep(경계 표현)이나 CSG(Constructive Solid Geometry) 같은 수학적 스케치와 돌출(Extrude) 명령어 시퀀스를 생성할 수 있어야 한다.

이러한 치수 제어 및 파라메트릭 모델링, 그리고 공간 지능(LWM)을 향해 연구되고 있는 오픈소스 및 프로젝트들을 엄선해 조사했다.

파라메트릭 CAD 생성 및 절차적 3D 모델 (AI to CAD)

단순한 메쉬(.obj)가 아니라, 치수를 조절할 수 있는 STEP 파일이나 CAD 명령어 스크립트를 생성하는 프로젝트들이다.

DeepCAD (A Deep Generative Network for CAD Models)

• 설명: 3D CAD 모델을 단순한 3D 도형이 아니라, '스케치(Profile) → 돌출(Extrude) → 필렛(Fillet)' 같은 CAD 명령어의 시퀀스로 인식하고 생성하는 선구적인 프로젝트이다. AI가 설계자의 작업 순서를 학습하여 파라메트릭 수정이 가능한 데이터를 추출한다.
• 특징: 출력물이 명령어 시퀀스이므로 Fusion 360이나 SolidWorks 같은 툴에서 치수를 즉각적으로 수정할 수 있다.
• GitHub: ChrisWu1997/DeepCAD

[3D 스캔/점군] → PointNet++ → z → Decoder → [CAD 시퀀스. L | A | E(θ,φ,e1,e2)]

Zoo Text-to-CAD API

• 설명: 텍스트를 입력하면 (예: "20개의 톱니가 있고 중심축 구멍 지름이 5mm인 기어") 즉석에서 파라메트릭 CAD 코드(KCL - KittyCAD Language)를 생성하여 STEP, IGES 등의 포맷으로 변환해 주는 프로젝트이다.
• 특징: 기하학적 제약 조건(Constraints)을 AI가 이해하고 코드로 작성하기 때문에 완벽한 치수 제어가 가능하다. 핵심 엔진 부분을 오픈소스로 공개하며 발전하고 있다.
• GitHub: Zoo-dev / kittyCAD 인프라

Infinigen

• 설명: 자연계와 사물을 100% 절차적(Procedural)인 수학 공식과 노드(Node) 트리로 생성해 내는 거대한 3D 프레임워크이다.
• 특징: "나뭇잎의 길이", "의자 다리의 두께" 등을 파라미터(수치)로 조절할 수 있다. 가우시안 덩어리가 아니라 처음부터 수학적 규칙으로 짜인 세계를 만들기 때문에 완벽한 편집이 가능하다.
• GitHub: princeton-vl/infinigen

공간 지능 (Spatial Intelligence) 및 LWM(Large World Model)

단순한 2D의 연속이 아니라 물리적 3D 공간의 깊이, 기하학, 영속성을 이해하는 기초 모델(Foundation Model) 연구이다.

LargeWorldModel (LWM) - UC Berkeley

• 설명: 프로젝트 이름 자체가 LWM이다. 100만(1M) 토큰의 컨텍스트 창을 가진 비디오/언어 모델이다.
• 특징: 긴 영상이나 여러 장의 이미지를 보고 그 안의 3D 공간 구조를 기억하고 이해한다. 당장 CAD 모델을 뱉어내는 용도는 아니지만, AI가 다중 시점을 통해 공간의 3차원적 기하학(Geometry)을 스스로 깨우치게 만드는 '공간 지능'의 가장 대표적인 베이스라인 모델이다.
• GitHub: LargeWorldModel/LWM

Zero123

• 설명: 단일 이미지를 보고 물체의 보이지 않는 뒷면과 다른 각도의 시점을 기하학적으로 일관되게 추론해 내는 모델이다.
• 특징: 이 기술 자체는 파라메트릭 CAD가 아니지만, 2D 이미지를 3D 파라메트릭 데이터로 역설계(Reverse Engineering)하기 위해 필수적으로 거쳐야 하는 "공간의 시점 변화 이해"를 담당한다.
• GitHub: SUDO-AI-3D/zero123plus

현재 기술의 한계와 돌파구

현재의 한계 (Image to 3D): 이미지를 보고 가우시안 스플래팅이나 메쉬(OBJ)를 만드는 것은 빠르지만, 산업용 설계나 정밀한 편집에는 한계가 명확하다.
미래의 방향 (AI to CAD): LWM과 공간 지능이 발전함에 따라, AI가 이미지를 분석한 뒤 "이것은 반지름 5cm의 원통과 10x10의 직육면체가 결합된 형태"라고 수학적으로 분해(CSG)하여 코드를 짜주는 방식으로 발전하고 있다. 그 선두에 DeepCAD와 Zoo(Text-to-CAD) 같은 프로젝트가 위치해 있다. 가우시안 스플래팅(3DGS)은 시각적 복원에 초점을 맞추기 때문에 스케일이 없는(Non-scale) 폴리곤 메쉬만을 생성할 뿐, 산업용으로 조작 가능한 CSG나 B-rep 데이터를 만들지 못한다.

부록: 두 방식 발전 방향
두 방식 중 어느 것이 '더 좋은가'는 목적에 따라 완전히 갈리며, 페이페이 리(Fei-Fei Li) 교수의 월드랩스(World Labs)가 추구하는 거대 세계 모델(LWM)의 방향성도 이 두 기술의 교차점에 있다. 이를 심층적으로 분석하고 최신 SOTA 프로젝트를 조사한다.

시퀀스 생성(DeepCAD 계열) vs 시각적 렌더링(3DGS 계열) 비교

결론부터 말하자면, 제조/설계(AEC/CAD) 분야에서는 DeepCAD 방식이 압도적으로 우월하고, 엔터테인먼트/가상현실/로보틱스 비전 분야에서는 3DGS 방식이 절대적으로 유리하다.

먼저 DeepCAD 계열(AI to CAD Sequence)은 산업용 설계 도면을 만들어내는 데 특화되어 있다. 이 기술의 핵심 원리는 3D 형상의 겉모습만 묘사하는 것이 아니라, 대상을 모델링하기 위한 수학적 명령어의 순서를 인공지능이 직접 추론해 내는 것이다. 그 결과물은 단순한 점토 덩어리가 아니라, 실제 설계 프로그램에서 즉시 다룰 수 있는 파라메트릭 CAD 데이터(STEP, IGES, CSG 스크립트 등) 형태로 출력된다. 이 방식의 가장 큰 무기는 완벽한 절대 치수 제어와 세밀한 곡률 반경 수정이 가능하다는 점이다. 하지만 수학적인 공식으로 딱 떨어지지 않는 자연물(사람, 나무 등)이나 비정형적이고 복잡한 형상을 표현하는 데는 뚜렷한 한계를 보인다.

반면 가우시안 스플래팅(Image to 3DGS/Mesh)은 현실 세계의 시각적인 복원에 모든 초점을 맞추고 있다. 빛의 반사와 색상 정보를 지닌 무수히 많은 타원체 입자를 3D 공간에 흩뿌려 세상을 사실적으로 표현하는 것이 핵심 원리이다. 그렇기 때문에 결과물 역시 속이 꽉 찬 설계 데이터가 아니라, 텅 빈 공간에 떠 있는 포인트 클라우드나 비정형 메쉬(PLY, OBJ) 형태로 도출된다. 이 방식은 사진처럼 정밀하고 압도적인 시각 효과를 주지만, 물리적인 절대 치수(Scale) 개념이 없고 임의의 상대 비율만 존재하여 토폴로지(구조) 편집이 원천적으로 불가능하다. 따라서 0.1mm의 오차도 허용되지 않는 산업용 금형 제작이나 정밀 조립을 위한 공차 설계 등에는 사용할 수 없다.

최근의 산업 트렌드는 이 둘을 결합하여, "3DGS로 현실 세계를 빠르게 스캔한 뒤, AI가 그 포인트 클라우드에서 기하학적 특징(원통, 평면 등)을 역산하여 CAD 시퀀스로 변환하는 방식(Scan-to-BIM / Scan-to-CAD)"으로 진화하고 있다.

각 계열의 최신 SOTA 깃허브 프로젝트

A. CAD 시퀀스 및 B-rep 생성 (DeepCAD의 진화형)
단순히 모양을 맞추는 것을 넘어, 위상(Topology)과 스케치 제약 조건(Constraints)을 완벽하게 학습하는 모델들이다.

SkexGen (Sketch-and-Extrude Generation)

설명: DeepCAD를 발전시켜, 트랜스포머(Transformer) 구조를 이용해 2D 스케치 프로파일과 돌출(Extrude) 파라미터를 자동 회귀(Autoregressive) 방식으로 생성하는 최신 모델이다. 토폴로지 일관성이 훨씬 뛰어나다.

Hextree / SECAD-Net

설명: CAD 모델의 모서리(Edge)와 면(Face)의 상호작용을 그래프(Graph) 신경망으로 학습하여, 훨씬 복잡한 솔리드(Solid) 모델을 B-rep 형태로 생성해 낸다.

GitHub: Puhao11/SECAD-Net

B. 기하학적 정밀도를 높인 가우시안 스플래팅 (3DGS의 진화형)
3DGS의 단점인 '수학적 표면(Surface)이 없다'는 문제를 해결하여, 고품질의 메쉬를 뽑아내기 위한 모델들이다.

SuGaR (Surface-Aligned Gaussian Splatting)

설명: 가우시안 타원체들이 물체의 실제 표면에 납작하게 달라붙도록 강제(Alignment)하여, 3DGS에서 아주 깔끔하고 정확한 메쉬(Mesh)를 추출해 내는 SOTA 기술이다.

GitHub: Anttwo/SuGaR

2D Gaussian Splatting (2DGS)

설명: 3D 부피를 가진 타원체 대신 2D 디스크 형태의 가우시안을 사용하여 형상의 경계와 표면을 극도로 정밀하게 재구성한다. 자율주행이나 로보틱스 매핑에 많이 쓰인다.

GitHub: hbb1/2d-gaussian-splatting

페이페이 리 교수(World Labs)의 LWM 설계 방식 

페이페이 교수는 수학적 기반의 B-rep이나 파라메트릭 CAD 전문가는 아니지만, 컴퓨터 비전(ImageNet 창시자)과 로보틱스(Embodied AI)의 권위자로서 '카메라 렌즈를 통해 3D 물리 공간의 구조와 깊이를 추론하는 방식'에는 세계 최고 수준의 이해도를 가지고 있다.

따라서 월드랩스의 LWM(마블)은 제조용 CAD 생성이 아니라, 물리 법칙이 작용하는 시뮬레이션 환경 구축에 초점을 맞추어 다음과 같이 설계될 것이다.

• 입력 및 추론 (2D/비디오 파운데이션 기반): 디퓨전 모델이나 트랜스포머가 단일 이미지/텍스트를 입력받아 보이지 않는 뒷면과 공간의 깊이(Depth)를 추론한다. (Zero123과 유사한 공간 상상력).
• 공간의 표현 (하이브리드 3DGS/NeRF): 생성된 공간을 B-rep이나 명령어 시퀀스가 아니라, 렌더링 속도가 빠른 3DGS나 Neural Fields로 빠르게 메모리에 올린다.
• 물리적 지능 부여 (Semantic & Physical Grounding): 여기가 마블(Marble)의 핵심이 될 것이다. 단순한 픽셀 덩어리(3DGS)에 분할(Segmentation) 라벨을 씌워 "이 가우시안 덩어리는 '유리'이고 깨질 수 있다", "저 덩어리는 '의자'이며 중력의 영향을 받는다"라는 물리적 속성을 부여한다.
• 출력 (Interactive 3D World): 치수 측정이 가능한 CAD가 아니라, 언리얼 엔진이나 오토데스크 Maya에서 즉시 카메라를 돌려보고 객체를 물리적으로 움직여볼 수 있는 '인터랙티브 3D 씬(Scene)' 자체를 내뱉는다.

CAD 진영(DeepCAD)은 설계 도면을 역공학하는 방향으로 발전하고 있고, 비전 진영(World Labs, 3DGS)은 카메라에 찍힌 세상에 물리 엔진을 덧씌워 가상 현실을 창조하는 방향으로 평행선을 달리고 있다.

 
최근의 역설계 SOTA 모델들은 이 두 가지(신경망의 패턴 인식 + 수학적 피팅)를 하나의 파이프라인으로 합친 미분 가능한 피팅(Differentiable Fitting) 방식을 사용한다.

신경망이 점들을 분류하고 치수를 대략 추정하면, 수학적 오차(Loss)가 발생한다. 이 오차 값을 역전파(Backpropagation) 시켜서 다시 신경망을 훈련하는 구조다. 즉, AI가 단순히 '비슷하게 생겼네'하고 끝내는 것이 아니라, "내가 예측한 원통의 반지름이 실제 스캔 점들의 분포와 수학적으로 0.2mm 오차가 있으니 가중치를 수정해야겠다"라고 스스로 학습하는 경지에 이르렀다. (관련 대표 오픈소스: ParseNet, HPNet)

레퍼런스

• BGPSeg: Boundary-Guided Primitive Instance Segmentation of Point Clouds