📸 사진 정리 자동화 프로젝트 계획 v2

프로젝트 개요: NAS에 분산 저장된 사진의 중복 검출 및 자동 정리
작성자: 하늘이 + 8개 모델 협동 분석
시작일: 2026-04-21
상태: ⏳ 계획 중

0. 모델 협동 분석 요약

💡 glm-5.1, qwen3.5, minimax-m2.5, gemma4:31b, deepseek-r1, llama3.1 6개 모델이
기존 계획을 리뷰하고 개선안을 제시함 (moondream, gemma4:e2b은 실전에서 활용)

공통 지적사항 (6개 모델 모두 동의)

#	문제점	개선방안
1	SHA-256만으로는 리사이즈/포맷변경 중복 감지 불가	pHash(지각적 해시) 병행 도입
2	NAS 3개소分散 스캔 → 네트워크 I/O 병목	파일 크기 기반 1차 필터링 → 해시 계산 최소화
3	서브에이전트에 없는 모델(kimi-k2.5, minimax-m2.7) 포함	실제 설치된 8개 모델로만 구성
4	Phase 2 “중복처리” 기준 모호	보존 우선순위 명확한 규칙으로 정의
5	LLM 역할 분담 불명확	모델 특성에 맞게 명확 배분

1. 현황 파악

1.1 사진 저장소 (실측 완료 ✅)

#	저장소	WSL 경로	사진 수	용량	마운트
1	백업NAS - 라이트룸	`/mnt/bk_nas/backup/pinksky/개인관련/Media/라이트룸사진/Lightroom CC/a22a72c5542f4eacb44a1978b389d014/originals/`	1,247장	-	✅ SMB
2	백업NAS - PhotoLibrary	`/mnt/bk_homes/pinksky/Photos/PhotoLibrary/`	1,254장	-	✅ SMB
3	개인NAS - 모바일백업	`/mnt/nas_homes/pinkskys/Photos/MobileBackup/`	-	~161GB	✅ SMB
4	개인NAS - PhotoLibrary	`/mnt/nas_homes/pinkskys/Photos/PhotoLibrary/`	15장	1.4GB	✅ SMB
5	개인NAS - photo	`/mnt/nas_photo/`	-	-	✅ SMB

모바일백업 상세 (개인NAS):

폴더	용량
아이폰백업예전꺼	54GB
iPhone	32GB
정환의 S21	17GB
정환의 Z Flip4	16GB
정환자급제	11GB
MH_S20U	12GB
주영의 Z Fold7	8.5GB
PS_SE3	3.2GB
주영의 S21	3.3GB
정환의 S20 Ultra	3.9GB

마운트 정보:

/mnt/minicity    → 개인NAS Backup_data (WebDAV)
/mnt/nas_photo   → 개인NAS photo (SMB)
/mnt/nas_homes   → 개인NAS homes (SMB)
/mnt/bk_nas      → 백업NAS 14T-HDD (SMB)
/mnt/bk_homes    → 백업NAS homes (SMB)

1.2 문제점

정확한 중복: 3개소 경로에 동일 파일이 존재 (→ SHA-256로 검출)
유사 중복: 리사이즈, 포맷변환,轻微편집으로 해시는 다르지만 같은 사진 (→ pHash로 검출)
파일명 변경: 파일명이 바뀌어도 같은 사진
정리 필요: 향후 과제로 미루어짐

2. 목표

2.1 단기 목표 (이번에 달성)

1차 중복 검출 - SHA-256 해시 기반 정확한 중복 찾기
2차 유사 검출 - pHash 기반 시각적 유사 중복 찾기
중복 정리 - 원본 유지, 중복 파일 이동/삭제
보고서 생성 - 어떤 파일이 어떤 경로에 있는지 기록

2.2 중기 목표

스마트 분류 - moondream으로 사진 내용 분석 → 연도/월/장소 자동 정리
스크린샷 분리 - moondream + EXIF로 스크린샷/문서사진 vs 일반사진 구분
중요 사진 표시 - 포토라이브러리 메타데이터 활용
백업 검증 - 정리 후 백업 무결성 확인

2.3 장기 목표

인물/장소 인식 - moondream Vision 분석으로 자동 태깅
색상 분석 - 스크린샷, 문서, 일반 사진 자동 구분
자동 아카이브 - 오래된 사진 자동 백업 이동

3. 구현 아키텍처

3.1 시스템 구성도 (v2)

┌──────────────────────────────────────────────────────────────────┐
│                    사진 정리 파이프라인 v2                        │
├──────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌──────────┐   ┌──────────────┐   ┌──────────┐   ┌──────────┐  │
│  │ 1.스캔   │ → │ 2.1차필터    │ → │ 3.해시   │ → │ 4.중복   │  │
│  │ 파일발견 │   │ 크기기준정렬 │   │ SHA-256  │   │ 그룹핑   │  │
│  └──────────┘   └──────────────┘   └──────────┘   └──────────┘  │
│       │              │                  │              │          │
│       │              │                  │              v          │
│       │              │                  │        ┌──────────┐    │
│       │              │                  │        │5.유사검출│    │
│       │              │                  │        │ pHash   │    │
│       │              │                  │        └──────────┘    │
│       │              │                  │              │          │
│       v              v                  v              v          │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │              🤖 멀티모델 분석 (8개 모델 협동)            │   │
│  │                                                          │   │
│  │  ┌─Phase 1─────────────────────────────────────────┐     │   │
│  │  │ 🖼️ moondream    → 이미지 내용 분석/캡셔닝      │     │   │
│  │  │ ⚡ gemma4:e2b   → 경량 EXIF 메타데이터 추출      │     │   │
│  │  └──────────────────────────────────────────────────┘     │   │
│  │                                                          │   │
│  │  ┌─Phase 2─────────────────────────────────────────┐     │   │
│  │  │ 🧠 qwen3.5:cloud → 중복 그룹 분석, 보존 순위     │     │   │
│  │  │ 📋 glm-5.1:cloud → 삭제/보존 규칙 생성           │     │   │
│  │  │ 🔬 deepseek-r1  → 복잡한 엣지 케이스 추론       │     │   │
│  │  └──────────────────────────────────────────────────┘     │   │
│  │                                                          │   │
│  │  ┌─Phase 3─────────────────────────────────────────┐     │   │
│  │  │ 📝 llama3.1    → 종합 보고서 작성               │     │   │
│  │  │ ✨ minimax-m2.5 → 최종 요약 및 권장 액션        │     │   │
│  │  │ 🎯 gemma4:31b  → 최종 검수 및 품질 보증         │     │   │
│  │  └──────────────────────────────────────────────────┘     │   │
│  └──────────────────────────────────────────────────────────┘   │
│                              │                                    │
│                              v                                    │
│                        ┌──────────┐                              │
│                        │ 6.정리   │                              │
│                        │Move/Del │                              │
│                        └──────────┘                              │
│                                                                   │
└──────────────────────────────────────────────────────────────────┘

3.2 모델 역할 배분 (8개 모델)

Phase	모델	역할	타입	이유
1. 스캔분석	`moondream`	이미지 내용 분석/캡셔닝	Local/Vision	🖼️ 사진이 무엇인지 파악
1. 스캔분석	`gemma4:e2b`	EXIF/메타데이터 경량 추출	Local	⚡ 빠른 로컬 처리
2. 중복판단	`qwen3.5:cloud`	중복 그룹 분석, 보존 우선순위	Cloud	🧠 분석/코딩 특화
2. 중복판단	`glm-5.1:cloud`	삭제/보존 규칙 생성	Cloud	📋 논리적 판단
2. 중복판단	`deepseek-r1`	복잡한 엣지 케이스 추론	Local	🔬 심층 추론
3. 보고서	`llama3.1`	종합 보고서 작성	Local	📝 자연어 생성
3. 보고서	`minimax-m2.5:cloud`	최종 요약 및 권장 액션	Cloud	✨ 요약 특화
3. 보고서	`gemma4:31b-cloud`	최종 검수 및 품질 보증	Cloud	🎯 대형 모델 검수

4. 상세 구현 계획

4.1 Phase 1: 스캔 + 1차 필터링 + 해시

💡 개선 (gemma4:31b 제안): 파일 크기 기반 1차 필터링 →
같은 크기의 파일만 해시 계산 → 네트워크 I/O 70% 절감

#!/usr/bin/env python3
"""1_scan_and_hash.py - 사진 스캔 및 해시 생성 v2"""

import os, hashlib, json
from pathlib import Path
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, as_completed

# 지원 확장자
EXTENSIONS = {'.jpg', '.jpeg', '.png', '.heic', '.heif', '.webp', '.mov', '.mp4', '.avi'}

def get_file_hash(filepath: str) -> str:
    """SHA-256 해시 계산 (8KB 청크)"""
    sha256 = hashlib.sha256()
    with open(filepath, 'rb') as f:
        for chunk in iter(lambda: f.read(8192), b''):
            sha256.update(chunk)
    return sha256.hexdigest()

def scan_and_hash(base_path: str) -> dict:
    """
    1차: 파일 크기별 그룹핑 (같은 크기만 해시 계산)
    2차: SHA-256 해시 계산
    """
    # Step 1: 파일 목록 + 크기 수집
    size_groups = defaultdict(list)
    file_info = {}

    print(f"📂 스캔 중: {base_path}")
    for root, _, files in os.walk(base_path):
        for file in files:
            ext = Path(file).suffix.lower()
            if ext in EXTENSIONS:
                filepath = os.path.join(root, file)
                try:
                    fsize = os.path.getsize(filepath)
                    size_groups[fsize].append(filepath)
                    file_info[filepath] = {'size': fsize, 'ext': ext}
                except OSError:
                    pass

    # Step 2: 같은 크기의 파일이 2개 이상인 경우만 해시 계산
    hash_map = defaultdict(list)
    total = sum(len(v) for v in size_groups.values() if len(v) >= 2)
    done = 0

    for size, paths in size_groups.items():
        if len(paths) < 2:
            continue  # 크기가 다르면 중복 불가 → 스킵
        for filepath in paths:
            try:
                fhash = get_file_hash(filepath)
                hash_map[fhash].append(filepath)
                done += 1
                if done % 100 == 0:
                    print(f"  🔢 해시 계산: {done}/{total}")
            except Exception as e:
                print(f"  ❌ 오류: {filepath} - {e}")

    # Step 3: 크기가 유일한 파일도 기록 (단일 파일)
    singles = {}
    for size, paths in size_groups.items():
        if len(paths) == 1:
            singles[paths[0]] = size

    return {
        'duplicates': {k: v for k, v in hash_map.items() if len(v) > 1},
        'unique_count': len(singles),
        'total_scanned': len(file_info),
    }

if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--path', required=True)
    parser.add_argument('--output', default='scan_result.json')
    parser.add_argument('--dry-run', action='store_true')
    args = parser.parse_args()

    result = scan_and_hash(args.path)

    with open(args.output, 'w') as f:
        json.dump(result, f, ensure_ascii=False, indent=2)

    dup_count = len(result['duplicates'])
    print(f"\n✅ 완료! 총 {result['total_scanned']}개 스캔, {dup_count}개 중복 그룹 발견")

4.2 Phase 2: pHash 유사 검출 (新增)

💡 gemma4:31b + minimax-m2.5 제안: SHA-256으로 못 잡는
리사이즈/포맷변환 중복을 pHash(Perceptual Hash)로 검출

#!/usr/bin/env python3
"""2_perceptual_hash.py - 지각적 해시 기반 유사 사진 검출"""

# 의존성: pip install imagehash Pillow
# (없으면 설치: pip install imagehash Pillow)

import os, json
from pathlib import Path
from PIL import Image
import imagehash

def get_phash(filepath: str, size: int = 8) -> str:
    """pHash 계산 (이미지가 열리지 않으면 None 반환)"""
    try:
        img = Image.open(filepath)
        return str(imagehash.phash(img, hash_size=size))
    except Exception:
        return None

def find_similar(base_path: str, threshold: int = 10) -> list:
    """
    pHash 해밍거리가 threshold 이하인 파일 쌍 찾기
    - threshold=0: 완전 동일 (SHA-256과 동일)
    - threshold=10: 약간의 차이 허용 (리사이즈, 경미한 편집)
    """
    hashes = {}

    for root, _, files in os.walk(base_path):
        for file in files:
            ext = Path(file).suffix.lower()
            if ext in {'.jpg', '.jpeg', '.png', '.webp'}:
                filepath = os.path.join(root, file)
                h = get_phash(filepath)
                if h:
                    hashes[filepath] = h

    # 유사 쌍 찾기
    similar_groups = []
    paths = list(hashes.keys())

    for i in range(len(paths)):
        for j in range(i + 1, len(paths)):
            h1 = imagehash.hex_to_hash(hashes[paths[i]])
            h2 = imagehash.hex_to_hash(hashes[paths[j]])
            distance = h1 - h2
            if distance <= threshold:
                similar_groups.append({
                    'file1': paths[i],
                    'file2': paths[j],
                    'distance': distance,
                })

    return similar_groups

4.3 Phase 3: 중복 처리 로직 (명확화)

💡 minimax-m2.5 + qwen3.5 제안: 보존 우선순위를 명시적 규칙으로

#!/usr/bin/env python3
"""3_process_duplicates.py - 중복 처리 (보존 우선순위 명확화)"""

import os, json

# 보존 우선순위 (1이 최고)
PRIORITY_RULES = [
    # 규칙 1: 라이트룸 originals 폴더 원본
    lambda f: 1 if 'originals' in f.lower() else 999,
    # 규칙 2: 파일명에 _original, _orig 포함
    lambda f: 2 if any(x in os.path.basename(f).lower() for x in ['_original', '_orig']) else 999,
    # 규칙 3: 파일 크기가 가장 큼 (원본 품질)
    lambda f: 3,  # 크기 비교는 아래에서 별도 처리
    # 규칙 4: 수정일이 가장 오래됨 (최초 생성)
    lambda f: 4,  # 날짜 비교도 별도 처리
    # 규칙 5: PhotoLibrary 경로
    lambda f: 5 if 'photolibrary' in f.lower() else 999,
]

def select_original(file_list: list) -> str:
    """
    중복 파일 목록에서 원본 선택
    우선순위: originals > _original 명칭 > 파일 크기 > 수정일 > 경로
    """
    scored = []
    for f in file_list:
        priority = 999
        for i, rule in enumerate(PRIORITY_RULES[:2]):  # 경로 기반 규칙
            p = rule(f)
            if p < priority:
                priority = p

        fsize = os.path.getsize(f) if os.path.exists(f) else 0
        mtime = os.path.getmtime(f) if os.path.exists(f) else 0
        scored.append((f, priority, -fsize, mtime))  # 크기는 큰게 좋으니 음수

    # 우선순위 → 크기(큰것) → 수정일(오래된것) 순 정렬
    scored.sort(key=lambda x: (x[1], x[2], -x[3]))
    return scored[0][0]  # 가장 우선순위 높은 파일 = 원본

def process_duplicates(scan_result: dict, dry_run: bool = True) -> list:
    """중복 처리 실행"""
    actions = []

    for hash_key, file_list in scan_result.get('duplicates', {}).items():
        if len(file_list) < 2:
            continue

        original = select_original(file_list)
        duplicates = [f for f in file_list if f != original]

        for dup in duplicates:
            action = {
                'original': original,
                'duplicate': dup,
                'action': 'move',  # 삭제 대신 이동 (안전)
                'destination': dup.replace('/originals/', '/duplicates/'),
            }
            actions.append(action)

            if not dry_run:
                os.makedirs(os.path.dirname(action['destination']), exist_ok=True)
                os.rename(dup, action['destination'])

    return actions

4.4 Phase 4: moondream 이미지 분석 (新增)

💡 moondream 전용 역할: 사진 내용 분석 →
스크린샷/문서/인물/풍경 자동 분류

#!/usr/bin/env python3
"""4_moondream_classify.py - Vision 모델로 사진 분류"""

import json, urllib.request, base64
from pathlib import Path

def classify_image(image_path: str) -> dict:
    """moondream으로 이미지 분류"""
    with open(image_path, 'rb') as f:
        img_b64 = base64.b64encode(f.read()).decode('utf-8')

    payload = {
        "model": "moondream",
        "messages": [{
            "role": "user",
            "content": "이 사진을 분류해줘. 답변은 JSON으로: {category, description, is_screenshot}",
            "images": [img_b64]
        }],
        "stream": False,
        "options": {"num_predict": 200}
    }

    req = urllib.request.Request(
        "http://127.0.0.1:11434/api/chat",
        data=json.dumps(payload).encode('utf-8'),
        headers={'Content-Type': 'application/json'}
    )

    with urllib.request.urlopen(req, timeout=60) as resp:
        data = json.loads(resp.read().decode('utf-8'))

    return data.get('message', {}).get('content', '')

5. 작업 순서

5.1 단계별 할 일

단계	작업	담당 모델	예상 시간
1	스캔 스크립트 작성	qwen3.5:cloud + minimax-m2.5	30분
2	의존성 설치 (imagehash, Pillow)	-	5분
3	🧪 테스트 실행 (작은 샘플 ~50장)	-	30분
4	전체 스캔 실행	-	2~4시간
5	pHash 유사 검출	moondream + gemma4:e2b	1~2시간
6	중복 분석 LLM 활용	qwen3.5 + glm-5.1 + deepseek-r1	30분
7	정리 실행 (dry-run)	-	30분
8	🔍 최종 검수	gemma4:31b-cloud	30분
9	보고서 작성	llama3.1 + minimax-m2.5	20분
10	✅ 실제 정리 실행 (dry-run 확인 후)	-	1시간

5.2 멀티모델 협동 흐름

    ┌─────────────────────┐
    │   스캔 결과 JSON    │
    └──────────┬──────────┘
               │
    ┌──────────▼──────────────────────────────────┐
    │          Phase 1: 스캔 분석                  │
    │  moondream ─→ 이미지 내용 캡셔닝           │
    │  gemma4:e2b ─→ EXIF/메타데이터 추출         │
    └──────────┬──────────────────────────────────┘
               │
    ┌──────────▼──────────────────────────────────┐
    │          Phase 2: 중복 판단                  │
    │  qwen3.5:cloud ─→ 그룹 분석/보존순위        │
    │  glm-5.1:cloud ─→ 삭제/보존 규칙 생성      │
    │  deepseek-r1  ─→ 엣지 케이스 추론           │
    └──────────┬──────────────────────────────────┘
               │
    ┌──────────▼──────────────────────────────────┐
    │          Phase 3: 보고서 + 검수              │
    │  llama3.1     ─→ 종합 보고서 작성           │
    │  minimax-m2.5 ─→ 최종 요약/권장액션         │
    │  gemma4:31b   ─→ 품질 검수/최종승인         │
    └─────────────────────────────────────────────┘

6. 실행 명령어

6.1 환경 준비

# 의존성 설치
pip install imagehash Pillow

# 실제 NAS 경로 확인
ls /mnt/minicity/

6.2 스크립트 실행

# Step 1: SHA-256 스캔 (1차)
python3 1_scan_and_hash.py --path /mnt/minicity --output scan_result.json

# Step 2: pHash 유사 검출 (2차)
python3 2_perceptual_hash.py --path /mnt/minicity --output similar_result.json

# Step 3: 중복 처리 (dry-run)
python3 3_process_duplicates.py --input scan_result.json --dry-run

# Step 4: moondream 분류
python3 4_moondream_classify.py --input scan_result.json --output classify_result.json

# Step 5: 실제 실행 (dry-run 결과 확인 후!)
python3 3_process_duplicates.py --input scan_result.json

6.3 LLM 협동 분석

# 중복 그룹 LLM 분석 (3개 모델 병렬)
ollama run qwen3.5:cloud "이 중복 사진 그룹들을 분석..."
ollama run glm-5.1:cloud "삭제/보존 규칙을 생성..."
ollama run deepseek-r1 "복잡한 중복 케이스를 판단..."

7. 주의사항

⚠️ 중요 (모델 공통 지적):

백업 필수 - 정리 전 반드시 전체 폴더 백업
Dry-run 선행 - 실제 삭제하기 전에 dry-run으로 테스트
원본 보존 - 항상 원본 파일 1개는 유지 (삭제 대신 이동)
로그 저장 - 모든 작업을 로그로 기록 (복구 가능)
pHash 임계값 주의 - threshold 너무 낮으면 놓치고, 너무 높으면 오탐
네트워크 안정성 - NAS 연결 끊기면 해시 계산 실패 → 재시도 로직 필요
메모리 관리 - 207GB 모바일 백업은 청크 단위로 처리

8. 관련 문서

[[MiniCITY(v0.5_PARA_0502-)/01_PROJECTS(프로젝트)/F_자료정리-PhotoVault/PS.BOT-F-01-개요]] - 기존 자료 개요
[[MiniCITY(v0.5_PARA_0502-)/02_AREAS(영역)/에이전트/LLM-모델/LLM_모델_목록]] - 사용 모델 정보

9. 업데이트 로그

날짜	작성자	내용
2026-04-21	하늘이	v1 초기 계획 작성
2026-04-21	하늘이 + 8모델	v2 멀티모델 협동 분석 반영

[!note] 수정이력 | 2026-04-21 06:XX, 하늘이 (v2)

🚧 진행 상황:

계획서 v1 작성

8모델 협동 분석 완료

계획서 v2 업데이트

의존성 설치 (imagehash, Pillow)

스크립트 작성

테스트 실행

전체 스캔

정리 실행

보고서 작성