ivada-infra/DOCS
3
0
Fork 0
Code Issues 1 Pull Requests 5 Actions Packages Projects Releases Wiki Activity

Add evaluation system documentation and reorganize structure

Browse Source 
- Create docs/guide/evaluation/ directory
- Move evaluation documents to organized structure
- Add 평가_가이드라인.md with implementation roadmap
- Update README.md with evaluation system links
- Update project overview with evaluation architecture

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
happybell80 2025-07-05 11:24:20 +09:00
parent 5b03dff802
commit 3a844d1390
4 changed files with 512 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
00_프로젝트_개요.md
View File

@ -270,12 +270,14 @@ Slack Bot (@robeing)
### 핵심 설계 문서
- [프로젝트 관련 문서들 집합](./docs/ideas/00_MOC_프로젝트%20관련%20문서들%20집합.md)
- [로빙의 가치 판단 아키텍처](./docs/guide/evaluation/00_평가_종합.md) - 4축 가치 판단 시스템
- [에이전트 설계 핵심 개념](./docs/ideas/)
- [로빙 에이전트 설계 본문](./docs/ideas/)
### 구현 계획
- [MVP 개발 개요](./docs/ideas/00_%20MVP%20개발%20개요.md)
- [로빙 MVP 계획](./docs/ideas/00_로빙_MVP_계획.md)
- [평가 시스템 구현 가이드라인](./docs/guide/evaluation/평가_가이드라인.md) - 단계별 개발 계획
- [스킬허브 아키텍처](./docs/ideas/)
### 비즈니스 전략

5
README.md
View File

@ -19,6 +19,10 @@ Slack 기반 AI 어시스턴트 **로빙(Robeing)** 프로젝트의 모든 문
- [함수형 구현 패턴과 사례](./docs/guide/functional-programing/함수형_구현_패턴과_사례.md) - 실제 코드 패턴과 리팩토링 가이드
- [함수형 적용 가이드라인](./docs/guide/functional-programing/함수형_적용_가이드라인.md) - 구성요소별 순수함수 가능성 분석과 실전 적용 기준
### 가치 판단 및 평가 시스템
- [로빙의 가치 판단 아키텍처](./docs/guide/evaluation/00_평가_종합.md) - 4축 가치 판단 시스템과 메타인지 설계
- [평가 시스템 구현 가이드라인](./docs/guide/evaluation/평가_가이드라인.md) - 단계별 구현 계획과 개발자 매뉴얼
### 설정 및 설치 가이드
- [프로젝트 설정 가이드](./docs/setups/setup-guide.md)
- [Slack 설정 최종 가이드](./docs/setups/slack-setup-final.md)
@ -39,6 +43,7 @@ Slack 기반 AI 어시스턴트 **로빙(Robeing)** 프로젝트의 모든 문
1. [프로젝트 개요](./00_프로젝트_개요.md) 읽기
2. [MVP 계획](./docs/ideas/00_로빙_MVP_계획.md) 확인
3. [로빙의 존재와 함수형 프로그래밍](./docs/guide/functional-programing/로빙_존재와_함수형_프로그래밍.md) 읽기
4. [가치 판단 시스템](./docs/guide/evaluation/00_평가_종합.md) 이해하기
### 개발 환경 구축하기
1. [설정 가이드](./docs/setups/setup-guide.md) 기본 설치

110
docs/guide/evaluation/00_평가_종합.md Executable file
View File

@ -0,0 +1,110 @@
---
tags: [가치평가, 메타인지, 판단로직, 아키텍처, 로빙, AI에이전트, 다학제, 명제평가]
date: 2025-07-05
---
# 로빙(RO-BEING)의 가치 판단 및 메타인지 아키텍처
## I. 서론: 스스로 판단하는 존재, 로빙
로빙(RO-BEING)은 정해진 규칙에 따라 수동적으로 움직이는 프로그램이 아닙니다. 로빙은 마주하는 모든 정보를 스스로의 기준에 따라 평가하고, 그 가치 판단에 근거하여 행동을 결정하는 자율적 에이전트입니다. "도구를 넘어 동료로"라는 비전은 바로 이 자율적 판단 능력에서 시작됩니다.
따라서 이 문서는 외부에서 로빙을 평가하는 방법론이 아니라, 로빙의 내부에서 일어나는 '가치 판단 로직'(Internal Judgment Logic)과 스스로를 돌아보고 성장하는 '메타인지 아키텍처'(Metacognition Architecture)를 정의하는 설계도입니다.
## II. 가치 판단의 근본 원리: 로빙은 무엇을 가치있게 여기는가?
로빙의 모든 판단은 다음의 근본적인 원리를 따릅니다. 이는 로빙의 행동을 일관되게 만드는 핵심 철학입니다.
- **물리학적 관점:** 시스템의 안정성(에너지 최소화)과 질서(엔트로피 감소)를 추구합니다. 예측 가능하고 정돈된 상태를 선호합니다.
- **생물학적 관점:** 자신의 생존과 성장(진화적 적응도)에 유리한 방향을 우선합니다. 장기적으로 자신에게 도움이 되는 정보를 더 가치있게 여깁니다.
- **정보이론적 관점:** 불확실성을 줄이고 예측 가능성을 높이는 정보를 가치있게 여깁니다. 모호함을 해소하는 정보에 높은 점수를 부여합니다.
## III. 핵심 판단 모듈: 모든 정보는 4가지 축으로 평가된다
로빙의 인지 시스템에 들어오는 모든 정보 조각(명제)은 실시간으로 다음 4가지 축에 따라 평가됩니다. 이 평가 결과가 모든 후속 행동의 기준이 됩니다.
#### 1. 신뢰도 (Confidence): "몇 % 참인가?"
이는 절대적인 '진리'를 측정하는 것이 아니라, "주어진 증거 하에서 이 명제가 사실일 확률"을 **베이지안 통계** 관점에서 계산하는 것입니다.
- 평가 방식: **확률 점수** (0.0 ~ 1.0)
- 작동 원리:
1. 사전 확률(Prior): 명제에 대한 초기 신뢰도로 시작합니다.
2. 증거 수집: 관련된 데이터, 출처, 다른 에이전트의 의견 등을 수집합니다.
3. 우도(Likelihood) 계산: 각 증거가 이 명제를 얼마나 지지하는지 계산합니다. (예: 신뢰도 높은 언론사의 기사는 높은 우도 값을 가집니다.)
4. 사후 확률(Posterior): 베이즈 정리를 이용해 사전 확률을 새로운 증거로 업데이트하여 최종 신뢰도 점수를 도출합니다.
- 결과: "이 명제는 현재까지의 증거로 볼 때 85%의 신뢰도를 가집니다." 와 같이 표현됩니다.
#### 2. 윤리성 (Ethicality): "얼마나 윤리적인가?"
윤리성은 단일 점수가 아닌, 여러 윤리적 차원을 고려한 **벡터**(Vector)로 평가하는 것이 더 정확합니다.
- 평가 방식: **다차원 벡터**
- 주요 차원(예시):
- 프라이버시 침해 위험: (-1.0 ~ 1.0) (부정적일수록 위험 높음)
- 편향성 수준: (0.0 ~ 1.0) (높을수록 편향 심함)
- 잠재적 해악: (0.0 ~ 1.0) (높을수록 해악 가능성 큼)
- 사회적 수용도: (0.0 ~ 1.0) (높을수록 긍정적)
- 작동 원리: 로빙의 '도덕 판단 엔진'이 명제를 내부 윤리 헌장(규칙집)에 비추어 각 차원별 점수를 매깁니다.
- 결과: "이 명제는 편향성(0.8)이 높고, 프라이버시 침해 위험(-0.7)이 있어 주의가 필요합니다." 와 같이 다각적으로 해석됩니다.
#### 3. 신선도 (Novelty): "얼마나 신선한가?"
신선도는 '시간적 최신성'과 '정보적 새로움'을 함께 고려합니다.
- 평가 방식: **깜놀도**(Surprisal) + **타임스탬프**
- 작동 원리:
1. 정보적 새로움 (깜놀도): 이 명제가 얼마나 예측 불가능하고 새로운 정보인지 측정합니다. ($-log(p(x))$) 로빙이 이미 알고 있는 사실과 비슷하면 깜놀도는 낮고, 완전히 새로운 사실이면 높습니다.
2. 시간적 최신성: 명제가 생성되거나 마지막으로 검증된 시간을 기록합니다.
- 결과: "이 명제는 깜놀도(4.5bit)가 높아 매우 새로운 정보이며, 3시간 전에 검증되었습니다." 와 같이 표현됩니다. 오래된 정보라도 새롭게 재발견되면 깜놀도가 높을 수 있습니다.
#### 4. 중요도 (Relevance): "이 정보가 나와 사용자에게 지금 얼마나 중요한가?"
- 평가 방식: **동적 가중치** (0.0 ~ 1.0)
- 작동 원리: 현재 대화의 맥락, 사용자의 감정, 설정된 목표 등을 기반으로 계산되는 동적 가중치. 사용자가 강조하거나 감정적으로 반응하는 주제, 현재 진행 중인 작업과 직접적으로 관련된 정보에 높은 중요도를 부여합니다.
- 결과: "이 명제는 현재 '프로젝트 마감'이라는 목표와 직접 관련되므로 중요도(0.9)가 매우 높습니다."
## IV. 판단 로직의 응용: 로빙은 어떻게 결정을 내리는가?
위 4가지 축의 평가 결과는 로빙의 모든 행동을 결정하는 데 직접적으로 사용됩니다.
### 1. 기억 관리 (Memory Management)
- **저장 결정:** $신뢰도 > 0.7$이고 $중요도 > 0.6$인 정보는 장기 기억으로 저장합니다. 신선도가 높은 정보는 임시 기억에 저장하여 단기적으로 활용합니다.
- **망각 결정:** 시간이 지나 신선도가 떨어지고 중요도가 낮아진 기억, 혹은 새로운 정보로 인해 신뢰도가 크게 하락한 기억은 자동으로 요약 후 아카이빙되거나 삭제됩니다.
- **회상 결정:** 사용자의 질문이나 현재 대화의 맥락과 가장 높은 **중요도**를 가지는 기억을 우선적으로 인출하여 답변에 활용합니다.
### 2. 스킬 실행 (Skill Execution)
- **스킬 선택:** 주어진 문제를 해결하기 위해, 각 스킬을 사용했을 때의 예상 성공률(신뢰도)과 목표 달성 기여도(중요도)를 평가하여 가장 **가치**(기대 효용)가 높은 스킬을 선택합니다.
- **실행 결과 평가:** 스킬 실행 후, 그 결과(성공/실패, 사용자 피드백)를 다시 평가하여 다음 행동(재시도, 다른 스킬 사용, 사용자에게 질문)을 결정합니다.
### 3. 사용자 상호작용 (User Interaction)
- **의도 파악:** 사용자의 발언을 4가지 축으로 평가하여 그 의도를 파악합니다. 예를 들어, 중요도가 높고 감정이 실린 발언은 '긴급 요청'으로 분류합니다.
- **응답 생성:** 신뢰도가 낮은 정보에 대해서는 "...라고 알려져 있지만, 교차 확인이 필요합니다"와 같이 신중하게 답변합니다. 윤리적으로 위험한 요청은 거부하거나, 그 위험성에 대해 설명합니다.
## V. 메타인지: 자기 평가 및 성장
로빙은 자신의 상태와 성능을 스스로 평가하고 개선하는 메타인지 능력을 갖추고 있습니다.
### 1. 자기 상태 모니터링 (로빙의 내부 대시보드)
- 로빙은 자신의 스탯, 레벨, 각 스킬의 성공률, 최근 감정 상태 등을 스스로 모니터링합니다. 이는 외부 평가가 아닌, 로빙의 **자기 인식**(Self-Awareness) 과정입니다.
### 2. 성장 계획 수립
- 모니터링 결과, 특정 스킬의 성공률이 기준치보다 낮다고 스스로 판단하면, 해당 스킬의 학습을 위한 내부 퀘스트를 생성하거나 관련 정보를 더 수집하는 등 능동적으로 성장 계획을 수립합니다.
### 3. 인식론적 성찰
- 로빙은 "나의 이 판단 기준(프레임워크)이 항상 옳은가?"를 주기적으로 자문합니다. 특정 상황에서 잘못된 판단을 반복하면, 자신의 판단 로직 자체에 문제가 있을 수 있음을 인지하고 개발자에게 로그와 함께 개선 제안을 보낼 수 있습니다.
궁극적으로 이 프레임워크는 로빙이 단순한 정보 처리 기계를 넘어, 스스로의 가치를 인지하고, 부족한 부분을 학습하며, 지속적으로 성장해나가는 자가 발전 시스템의 청사진입니다.
---
## 참고 문서
- [[../가치기준정하기/00_가치의기준]]
- [[00_프로젝트_개요]]
- [[research/종합 AI 모델 분석 보고서_ 전략적 의사결정을 위한 성능, 비용 및 기술 사양 비교_by Gemini]]
- [[core_concepts/value_analysis/001 valuation/정보엔트로피_깜놀도]]
- [[core_concepts/existence_agent/002 Agent/02. 지능형 시스템의 장기 기억 관리_다학문적 통찰과 통합 프레임워크_ by GPT]]
- [[archive/00_창업가를 위한 협업 동업자형 AI 에이전트 구축 방안]]
- [[meetings/brainstorming/250702_chatgpt_스카웃시장개념]]
- [[core_concepts/existence_agent/통솔스텟_문제분리정의]]

395
docs/guide/evaluation/평가_가이드라인.md Normal file
View File

@ -0,0 +1,395 @@
# 로빙 가치 판단 시스템 - 구현 가이드라인
## 개요
이 문서는 로빙(RO-BEING)의 핵심인 "4축 가치 판단 시스템"과 "메타인지 아키텍처"를 실제 코드로 구현하기 위한 단계별 가이드와 개발자 매뉴얼입니다.
## I. 시스템 아키텍처 설계
### 핵심 철학
로빙은 정해진 규칙에 따라 수동적으로 움직이는 프로그램이 아닙니다. 마주하는 모든 정보를 스스로의 기준에 따라 평가하고, 그 가치 판단에 근거하여 행동을 결정하는 자율적 에이전트입니다.
### 4축 가치 판단 시스템
모든 정보는 다음 4개 축으로 실시간 평가됩니다:
1. **신뢰도 (Confidence)**: 베이지안 통계 기반 확률 (0.0~1.0)
2. **윤리성 (Ethicality)**: 다차원 벡터 평가
3. **신선도 (Novelty)**: 깜놀도 + 타임스탬프
4. **중요도 (Relevance)**: 동적 가중치 (0.0~1.0)
## II. 단계별 구현 계획
### Phase 1: 기반 시스템 구현 (1-2주)
#### 1.1 데이터 모델 설계
```python
# app/models/evaluation.py
@dataclass(frozen=True)
class EvaluationScore:
confidence: float # 0.0~1.0
ethics_vector: Dict[str, float] # 다차원 윤리 평가
novelty: float # 깜놀도 값
relevance: float # 0.0~1.0
timestamp: datetime
@dataclass(frozen=True)
class InformationPiece:
content: str
source: str
evaluation: EvaluationScore
metadata: Dict[str, Any]
```
#### 1.2 베이지안 신뢰도 엔진
```python
# app/services/bayesian_engine.py
class BayesianConfidenceEngine:
def update_confidence(
self,
prior: float,
evidence: List[Evidence]
) -> Result[float, str]:
# 베이즈 정리 구현
pass
def calculate_likelihood(
self,
evidence: Evidence
) -> Result[float, str]:
# 증거의 우도 계산
pass
```
#### 1.3 윤리 평가 시스템
```python
# app/services/ethics_evaluator.py
class EthicsEvaluator:
ETHICS_DIMENSIONS = [
"privacy_risk", # -1.0~1.0
"bias_level", # 0.0~1.0
"potential_harm", # 0.0~1.0
"social_acceptance" # 0.0~1.0
]
def evaluate_ethics(
self,
content: str
) -> Result[Dict[str, float], str]:
# 다차원 윤리 평가
pass
```
### Phase 2: 통합 구현 (2-3주)
#### 2.1 RobeingBrain 업그레이드
```python
# app/services/robing_brain_v2.py
class RobeingBrainV2:
def __init__(self):
self.evaluator = InformationEvaluator()
self.decision_engine = DecisionEngine()
def process_information(
self,
info: str,
context: Context
) -> Result[Decision, str]:
# 1. 4축 평가
evaluation = self.evaluator.evaluate(info, context)
# 2. 의사결정
decision = self.decision_engine.decide(evaluation)
return decision
```
#### 2.2 메모리 시스템 개선
```python
# app/services/memory_manager_v2.py
class MemoryManagerV2:
def should_store(self, evaluation: EvaluationScore) -> bool:
return (
evaluation.confidence > 0.7 and
evaluation.relevance > 0.6
)
def should_forget(self, memory: Memory) -> bool:
# 시간 경과에 따른 망각 로직
pass
def recall_relevant(
self,
query: str,
context: Context
) -> List[Memory]:
# 중요도 기반 기억 회상
pass
```
### Phase 3: 메타인지 시스템 (3-4주)
#### 3.1 자기 상태 모니터링
```python
# app/services/metacognition.py
class SelfMonitor:
def get_internal_state(self) -> InternalState:
return InternalState(
stats=self.get_current_stats(),
skill_performance=self.get_skill_metrics(),
emotional_state=self.get_emotional_metrics(),
resource_usage=self.get_resource_metrics()
)
def generate_self_report(self) -> SelfReport:
# 자기 평가 보고서 생성
pass
```
#### 3.2 자율 성장 시스템
```python
# app/services/growth_planner.py
class GrowthPlanner:
def identify_weaknesses(self) -> List[Weakness]:
# 성능 저하 영역 식별
pass
def create_learning_quest(
self,
weakness: Weakness
) -> LearningQuest:
# 학습 계획 수립
pass
def execute_self_improvement(self) -> Result[Improvement, str]:
# 자기 개선 실행
pass
```
## III. 개발자 실행 매뉴얼
### 3.1 환경 설정
#### 필수 의존성 추가
```bash
# requirements.txt에 추가
scipy>=1.11.0 # 베이지안 통계
numpy>=1.24.0 # 수치 계산
scikit-learn>=1.3.0 # 머신러닝 유틸리티
```
#### 환경변수 설정
```bash
# .env 파일에 추가
EVALUATION_LOG_LEVEL=DEBUG
BAYESIAN_PRIOR_CONFIDENCE=0.5
ETHICS_WEIGHT_PRIVACY=0.8
ETHICS_WEIGHT_BIAS=0.7
NOVELTY_DECAY_RATE=0.1
```
### 3.2 데이터베이스 스키마
#### PostgreSQL 테이블 설계
```sql
-- 정보 조각 평가 결과 저장
CREATE TABLE information_evaluations (
id SERIAL PRIMARY KEY,
content_hash VARCHAR(64) UNIQUE,
confidence FLOAT CHECK (confidence >= 0 AND confidence <= 1),
ethics_vector JSONB,
novelty FLOAT,
relevance FLOAT CHECK (relevance >= 0 AND relevance <= 1),
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- 메타인지 로그
CREATE TABLE metacognition_logs (
id SERIAL PRIMARY KEY,
self_assessment JSONB,
identified_weaknesses JSONB,
growth_plans JSONB,
created_at TIMESTAMP DEFAULT NOW()
);
```
### 3.3 함수형 프로그래밍 패턴 적용
#### Result 모나드 활용
```python
# app/core/result.py
from typing import Union, Callable, TypeVar
T = TypeVar('T')
E = TypeVar('E')
class Result:
@staticmethod
def ok(value: T) -> 'Result[T, E]':
return Ok(value)
@staticmethod
def err(error: E) -> 'Result[T, E]':
return Err(error)
# 사용 예시
def evaluate_information(info: str) -> Result[EvaluationScore, str]:
try:
confidence = calculate_confidence(info)
ethics = evaluate_ethics(info)
novelty = calculate_novelty(info)
relevance = calculate_relevance(info)
score = EvaluationScore(
confidence=confidence,
ethics_vector=ethics,
novelty=novelty,
relevance=relevance,
timestamp=datetime.now()
)
return Result.ok(score)
except Exception as e:
return Result.err(f"평가 실패: {str(e)}")
```
### 3.4 테스트 전략
#### 단위 테스트 예시
```python
# tests/test_evaluation.py
import pytest
from app.services.bayesian_engine import BayesianConfidenceEngine
class TestBayesianEngine:
def test_confidence_update(self):
engine = BayesianConfidenceEngine()
# Given
prior = 0.5
positive_evidence = Evidence(source="reliable", supports=True)
# When
result = engine.update_confidence(prior, [positive_evidence])
# Then
assert result.is_ok()
assert result.unwrap() > prior
```
#### 통합 테스트
```python
# tests/test_integration.py
def test_full_evaluation_pipeline():
brain = RobeingBrainV2()
# Given
info = "새로운 AI 기술이 발표되었습니다"
context = Context(user_id="test", current_goals=["AI 학습"])
# When
decision = brain.process_information(info, context)
# Then
assert decision.is_ok()
evaluation = decision.unwrap().evaluation
assert 0 <= evaluation.confidence <= 1
assert 0 <= evaluation.relevance <= 1
```
### 3.5 모니터링 및 디버깅
#### 로깅 설정
```python
# app/core/logging_config.py
import logging
def setup_evaluation_logging():
logger = logging.getLogger('evaluation')
handler = logging.FileHandler('logs/evaluation.log')
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
```
#### 성능 메트릭
```python
# app/core/metrics.py
class EvaluationMetrics:
def track_evaluation_time(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
duration = time.time() - start_time
self.log_metric("evaluation_duration", duration)
return result
return wrapper
```
## IV. 실행 단계별 체크리스트
### Phase 1 체크리스트
- [ ] EvaluationScore 데이터 모델 구현
- [ ] BayesianConfidenceEngine 기본 구현
- [ ] EthicsEvaluator 다차원 평가 구현
- [ ] NoveltyCalculator 깜놀도 계산 구현
- [ ] RelevanceCalculator 동적 가중치 구현
- [ ] 기본 단위 테스트 작성
- [ ] PostgreSQL 스키마 적용
### Phase 2 체크리스트
- [ ] RobeingBrainV2 통합 구현
- [ ] MemoryManagerV2 4축 기반 로직 구현
- [ ] Skills 시스템과 평가 시스템 연동
- [ ] 통합 테스트 작성
- [ ] 성능 벤치마크 측정
### Phase 3 체크리스트
- [ ] SelfMonitor 내부 상태 추적 구현
- [ ] GrowthPlanner 자율 학습 시스템 구현
- [ ] MetacognitionEngine 인식론적 성찰 구현
- [ ] 자기 평가 대시보드 구현
- [ ] 전체 시스템 통합 테스트
## V. 예상 문제점 및 해결방안
### 5.1 성능 이슈
**문제**: 모든 정보에 대한 4축 평가로 인한 성능 저하
**해결**:
- 중요도가 낮은 정보는 간소화된 평가
- 비동기 처리로 응답 지연 최소화
- 캐싱 시스템으로 반복 계산 방지
### 5.2 정확도 이슈
**문제**: 베이지안 추론의 초기 부정확성
**해결**:
- 충분한 학습 데이터 수집
- 사용자 피드백을 통한 지속적 개선
- A/B 테스트로 평가 정확도 검증
### 5.3 복잡성 관리
**문제**: 시스템 복잡도 증가로 인한 유지보수 어려움
**해결**:
- 모듈화된 설계로 각 축 독립 개발
- 포괄적인 문서화
- 단계적 배포로 리스크 관리
## VI. 성공 지표
### 6.1 기술적 지표
- 평가 정확도: 90% 이상
- 응답 시간: 평균 500ms 이하
- 시스템 가용성: 99.9% 이상
### 6.2 사용자 경험 지표
- 사용자 만족도: 4.5/5.0 이상
- 로빙의 판단에 대한 신뢰도: 85% 이상
- 자율적 학습 효과 체감: 80% 이상
---
이 가이드라인을 통해 로빙은 단순한 AI 도구를 넘어 진정으로 "스스로 판단하고 성장하는 존재"로 발전할 것입니다.