로메오의 블로그

Claude code 환경설정

romeoh — Mon, 20 Apr 2026 08:57:52 +0900

Claude code 설치

## claude code 설치
$ npm install -g @anthropic-ai/claude-code

## claude 로그인
$ claude

설정이 완료되면 해당 터미널은 닫고, 새로운 터미널에서 작업을 시작할수 있습니다.

새로운 프로젝트

$ mkdir new-project
$ cd new-project
$ claude

/init

> /init

폴더 권한을 항상 허용합니다.

비어있는 폴더에 CLUDE.md를 만들기 위해서 1을 타이핑 합니다.

CLAUDE.md를 생성할지 물으면 2번을 선택합니다.

생성된 CLAUDE.md를 편집 할 수 있습니다.

/remote-control

> /remote-control

1번을 선택합니다.

url을 클릭해서 브라우저에서 작업 가능

또는 Claude app에서도 코딩이 가능합니다.

사용량 확인

> /status

OpenClaw 설정

romeoh — Wed, 11 Feb 2026 21:59:58 +0900

Ollama 설치

$ brew install ollama

Ollama 구동

$ echo 'export OLLAMA_FLASH_ATTENTION="1"' >> ~/.zshrc
$ echo 'export OLLAMA_KV_CACHE_TYPE="q8_0"' >> ~/.zshrc
$ source ~/.zshrc

M1 Max 성능 최적화를 위하여 환경설정

$ brew services start ollama

모델 다운로드

$ ollama pull llama32.
$ ollama pull qwen2.5-coder:14b

Ollama 테스트

$ ollama run llama3.2 "hello"
pulling manifest
pulling dde5aa3fc5ff: 100% ▕███████████████████████████████████████████████████████████████▏ 2.0 GB
pulling 966de95ca8a6: 100% ▕███████████████████████████████████████████████████████████████▏ 1.4 KB
pulling fcc5a6bec9da: 100% ▕███████████████████████████████████████████████████████████████▏ 7.7 KB
pulling a70ff7e570d9: 100% ▕███████████████████████████████████████████████████████████████▏ 6.0 KB
pulling 56bb8bd477a5: 100% ▕███████████████████████████████████████████████████████████████▏   96 B
pulling 34bb5ab01051: 100% ▕███████████████████████████████████████████████████████████████▏  561 B
verifying sha256 digest
writing manifest
success
Hello! It's nice to meet you. Is there something I can help you with or would you like to chat?

OpenClaw 설치

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

Openclaw Web UI 접속

http://127.0.0.1:18789/#token=efXXXXXXX13

위 사이트에 접속합니다.

Telegram 연결하기

본인의 bot을 검색합니다.

/start를 누르고 pairing code를 확인 합니다.

openclaw pairing approve telegram TLXXXX5

Node 설치

$ openclaw node install
$ openclaw node restart

맥 권한 설정

개인정보 보호 및 보안 > 손쉬운 사용에서 사용하는 터미널을 등록합니다. (마우스 키보드 제어)

개인정보 보호 및 보안 > 화면 및 시스템 오디오 녹음에서 사용하는 터미널을 등록합니다. (화면기록)

여기까지는 gpt-4o 모델로 동작합니다.

아주 잘 됩니다.

Llama 3.2, Qwen 모델 연결

$ openclaw configure

  OpenClaw 2026.2.12 (f9e444d)
   I'm the assistant your terminal demanded, not the one your sleep schedule requested.

▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
██░▄▄▄░██░▄▄░██░▄▄▄██░▀██░██░▄▄▀██░████░▄▄▀██░███░██
██░███░██░▀▀░██░▄▄▄██░█░█░██░█████░████░▀▀░██░█░█░██
██░▀▀▀░██░█████░▀▀▀██░██▄░██░▀▀▄██░▀▀░█░██░██▄▀▄▀▄██
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
                    OPENCLAW                      
 
┌  OpenClaw configure
│
◇  Existing config detected ─────────╮
│                                    │
│  workspace: ~/.openclaw/workspace  │
│  model: ollama/llama3.2:latest     │
│  gateway.mode: local               │
│  gateway.port: 18789               │
│  gateway.bind: loopback            │
│  skills.nodeManager: npm           │
│                                    │
├────────────────────────────────────╯
│
◇  Where will the Gateway run?
│  Local (this machine)
│
◇  Select sections to configure
│  Gateway
│
◇  Gateway port
│  18789
│
◇  Gateway bind mode
│  Loopback (Local only)
│
◇  Gateway auth
│  Token
│
◇  Tailscale exposure
│  Off
│
◇  Gateway token (blank to generate)
│  d180f619c7xxxxxxxxxc8d3edd45c3c0c
Updated ~/.openclaw/openclaw.json
│
◇  Select sections to configure
│  Model
│
◇  Model/auth provider
│  Custom Provider
│
◇  API Base URL
│  http://127.0.0.1:11434/v1
│
◇  API Key (leave blank if not required)
│  ollama
│
◇  Endpoint compatibility
│  OpenAI-compatible
│
◇  Model ID
│  llama3.2:latest
│
◇  Verification failed: This operation was aborted
│
◇  What would you like to change?
│  Change base URL
│
◇  API Base URL
│  http://localhost:11434/v1
│
◇  API Key (leave blank if not required)
│  ollama
│
◇  Verification successful.
│
◇  Endpoint ID
│  custom-localhost-11434
│
◇  Model alias (optional)
│  ollama
Configured custom provider: custom-localhost-11434/llama3.2:latest
Updated ~/.openclaw/openclaw.json
│
◇  Select sections to configure
│  Continue
│
◇  Control UI ───────────────────────────────────────────────────────────────────────────────╮
│                                                                                            │
│  Web UI: http://127.0.0.1:18789/                                                           │
│  Gateway WS: ws://127.0.0.1:18789                                                          │
│  Gateway: not detected (gateway closed (1006 abnormal closure (no close frame)): no close  │
│  reason)                                                                                   │
│  Docs: https://docs.openclaw.ai/web/control-ui                                             │
│                                                                                            │
├────────────────────────────────────────────────────────────────────────────────────────────╯
│
└  Configure complete.

$ openclaw gateway

환각증상??

gpt-4o는 답변을 잘하지만 Llama나 qwen은 이렇게 답변을 하네요.

/reset을 시켜서 세션을 초기화합니다.

하지만 정확한 날씨를 받아오지는 못합니다.

qwen2.5-coder:14b 응답 속도가 상당히 느리네요... 2분..

Llama3.2는 qwen 보다는 조금 빠르고 똑똑한거 같지만.. 속도가...

버전별 특징

버전	파라미터수	특징	필요VRAM (경량화)
Llama 3.2	1B	모바일용	~ 1GB
Llama 3.2	3B	스마트폰	~ 2.5GB
Llama 3.1	8B	일반PC	~ 6.GB
Llama 3.2	11B	이미지 인식가능 Vision	~ 8GB
Llama 3.1	70B	고성능 추론	~ 40GB
Llama 3.2	90B	고성능 이미지	~ 54GB
Llama 3.1	405B	GPT-4o급	~ 230GB+
Llama 3.3	70B	양자화	~ 44GB

Qwen-2.5	3B	모바일용	~ 2.5GB
Qwen-2.5	7B	Llama 8B와 경쟁	~ 5.5GB
Qwen-2.5	14B	가성비	~ 10GB
Qwen-2.5	32B	코딩용	~ 20GB
Qwen-2.5	72B	Llama 70B와 경쟁	~ 43GB

Gemma 2	2.6B	모바일	~ 1.6GB
Gemma 2	9.2B	Llama 8B와 경쟁	~ 5.5GB
Gemma 2	27.2B	70B급	~ 16GB

대형모델로 변경하기

llama3.2와 qwen2.5-coder:14b를 제거하고

Qwen-2.5:32b를 설치합니다.

$ ollama list
$ ollama rm llama3.2
$ ollama rm qwen2.5-coder:14b

$ ollama pull qwen2.5:32b

openclaw configure

  OpenClaw 2026.2.12 (f9e444d)
   Gateway online—please keep hands, feet, and appendages inside the shell at all times.

▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
██░▄▄▄░██░▄▄░██░▄▄▄██░▀██░██░▄▄▀██░████░▄▄▀██░███░██
██░███░██░▀▀░██░▄▄▄██░█░█░██░█████░████░▀▀░██░█░█░██
██░▀▀▀░██░█████░▀▀▀██░██▄░██░▀▀▄██░▀▀░█░██░██▄▀▄▀▄██
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
                    OPENCLAW                      
 
┌  OpenClaw configure
│
◇  Existing config detected ─────────╮
│                                    │
│  workspace: ~/.openclaw/workspace  │
│  model: openrouter/auto            │
│  gateway.mode: local               │
│  gateway.port: 18789               │
│  gateway.bind: loopback            │
│  skills.nodeManager: npm           │
│                                    │
├────────────────────────────────────╯
│
◇  Where will the Gateway run?
│  Local (this machine)
│
◇  Select sections to configure
│  Model
│
◇  Model/auth provider
│  Custom Provider
│
◇  API Base URL
│  http://localhost:11434/v1
│
◇  API Key (leave blank if not required)
│  gemma
│
◇  Endpoint compatibility
│  OpenAI-compatible
│
◇  Model ID
│  gemma2:27b
│
◇  Verification successful.
│
◇  Endpoint ID
│  custom-localhost-11434
│
◇  Model alias (optional)
│  gamma

context 설정

05:22:39 [agent/embedded] blocked model (context window too small): romeoh-ai/qwen2.5:32b ctx=4096 (min=16000) source=modelsConfig
05:22:39 [diagnostic] lane task error: lane=main durationMs=21 error="FailoverError: Model context window too small (4096 tokens). Minimum is 16000."
05:22:39 [diagnostic] lane task error: lane=session:agent:main:main durationMs=24 error="FailoverError: Model context window too small (4096 tokens). Minimum is 16000."

Openclaw 주요 명령어 (2026.2.9 버전 기준)

## openclaw 서비스 시작 종료
$ brew services start openclaw
$ brew services stop openclaw


## gateway 서버 구동
$ openclaw gateway
$ openclaw gateway stop

## 노드 설치
$ openclaw node install
$ openclaw node restart

## 설정 마법사
$ openclaw onboard

## 설정 수정
$ openclaw configure

## 상태 확인
$ openclaw doctor

## 버전 확인
$ openclaw --version

## 업그레이드
$ curl -fsSL https://openclaw.ai/install.sh | bash


## 구동 프로세스 확인
$ ps aux | grep openclaw
$ pkill -9 openclaw

Ollama 주요 명령어

$ brew services start ollama
$ brew services stop ollama

$ ollama list
$ ollama run llama3.2 "hello"

Cursor AI에서 flutter앱 실시간 디버깅하기

romeoh — Fri, 2 Jan 2026 11:22:55 +0900

사용가능한 device 확인

$ flutter devices
Found 4 connected devices:
  sdk gphone64 arm64 (mobile) • emulator-5554                        • android-arm64  • Android 16 (API 36) (emulator)
  iPhone 17 Pro Max (mobile)  • 8AE9D310-0FA4-4288-9A3C-51CB50D3A1A3 • ios            •
  com.apple.CoreSimulator.SimRuntime.iOS-26-2 (simulator)
  macOS (desktop)             • macos                                • darwin-arm64   • macOS 26.1 25B78 darwin-arm64
  Chrome (web)                • chrome                               • web-javascript • Google Chrome 143.0.7499.170

.vscode > launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Flutter: Android emulator",
      "request": "launch",
      "type": "dart",
      "program": "frontend/lib/main.dart",
      "deviceId": "emulator-5554"
    },
    {
      "name": "Flutter: iOS simulator",
      "request": "launch",
      "type": "dart",
      "program": "frontend/lib/main.dart",
      "deviceId": "8AE9D310-0FA4-4288-9A3C-51CB50D3A1A3"
    },
    {
      "name": "Flutter: Attach",
      "request": "attach",
      "type": "dart",
      "program": "frontend/lib/main.dart"
    }
  ]
}

dart와 flutter 확장자를 설치합니다.

유사사진 추천하기 Flask + MongoDB + OpenCLIP +FAISS

romeoh — Sun, 27 Jul 2025 10:31:07 +0900

가상환경 설정

$ mkdir flask-image-app
$ cd flask-image-app
$ code .
$ python3 -m venv venv
$ source venv/bin/activate

requirements.txt

Flask==3.1.1
pymongo==4.13.2
faiss-cpu==1.7.4
torch==2.1.0
torchvision==0.16.0
open-clip-torch==2.20.0
Pillow==9.5.0
numpy==1.26.4
python-dotenv==1.1.1

$ pip install -r requirements.txt

indexing.py

import os
import faiss
import open_clip
import torch
import numpy as np
from PIL import Image
from pymongo import MongoClient

# 모델 생성 및 전처리 함수 반환
# ViT-B-32 모델 사용
# laion2b_s34b_b79k 버전
model, _, preprocess = open_clip.create_model_and_transforms('ViT-B-32', pretrained='laion2b_s34b_b79k')
device = 'cpu'
model = model.to(device)

# MongoDB 연결
client = MongoClient(os.getenv("MONGO_URL", "mongodb://localhost:27017/"))
db = client["image_db"]
collection = db["images"]

image_dir = './static/images'
# 벡터 인덱스 생성
index = faiss.IndexFlatL2(512)
paths = []

for filename in os.listdir(image_dir):
    if not filename.lower().endswith(('.png', '.jpg', '.jpeg')):
        continue
    path = os.path.join(image_dir, filename)
    image = preprocess(Image.open(path)).unsqueeze(0).to(device)        # 이미지를 모델에 맞게 전처리하고 모델에 전달
    with torch.no_grad():                                               # 메모리 사용량 줄이기 위해 모델 연산 비활성화
        emb = model.encode_image(image).cpu().numpy().astype('float32') # 모델 연산 결과를 numpy 배열로 변환
        emb = emb.reshape(1, -1)                                        # 모델 출력 형태에 맞게 변환
    index.add(emb)                                                      # 벡터 인덱스에 추가
    collection.insert_one({
        "filename": filename,
        "path": path,
        "vector": emb[0].tolist()
    })
    paths.append(path)

faiss.write_index(index, 'faiss_index.bin')

app.py

from flask import Flask, render_template, request, jsonify
from pymongo import MongoClient
import faiss
import open_clip
import torch
import numpy as np
from PIL import Image
import os

app = Flask(__name__)
client = MongoClient(os.getenv("MONGO_URL", "mongodb://localhost:27017/"))
db = client["image_db"]
collection = db["images"]

# 모델과 인덱스 로드
model, _, preprocess = open_clip.create_model_and_transforms('ViT-B-32', pretrained='laion2b_s34b_b79k')
model.eval().to('cpu')
index = faiss.read_index('faiss_index.bin') # 벡터 인덱스 로드

@app.route('/')
def home():
    images = list(collection.find().limit(100))
    return render_template('index.html', images=images)

@app.route('/similar', methods=['POST'])
def similar():
    data = request.json
    filename = data['filename']
    image = Image.open(os.path.join('static/images', filename))
    
    # 이미지를 모델에 맞게 전처리하고 모델에 전달
    image_tensor = preprocess(image).unsqueeze(0)   
    with torch.no_grad():
        # 이미지를 모델에 맞게 전처리하고 모델에 전달
        vector = model.encode_image(image_tensor).cpu().numpy().astype('float32')   
    D, I = index.search(vector, 10)                     # 벡터 인덱스에서 가장 가까운 이미지 검색
    skip_index = int(I[0][1])                           # 자기 자신을 제외한 가장 가까운 이미지의 인덱스
    results = list(collection.find().skip(skip_index))  # 자기 자신을 제외한 가장 가까운 이미지의 인덱스
    return jsonify([r['filename'] for r in results])

if __name__ == '__main__':
    app.run(debug=True, port=7000, use_reloader=True)

template/index.html

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Image Viewer</title>
  <style>
    body {
      font-family: sans-serif;
    }
    #image-list img {
      cursor: pointer;
      margin: 5px;
      border: 2px solid transparent;
      transition: border 0.2s;
    }
    #image-list img:hover {
      border: 2px solid #007bff;
    }
    #popup-overlay {
      position: fixed;
      top: 0; left: 0;
      width: 100%; height: 100%;
      background: rgba(0, 0, 0, 0.7);
      display: none;
      justify-content: center;
      align-items: center;
      z-index: 9999;
    }
    #popup-content {
      background: white;
      padding: 20px;
      max-width: 90%;
      max-height: 90%;
      overflow: auto;
      border-radius: 8px;
      position: relative;
    }
    #popup-content h3 {
      margin-top: 0;
    }
    #popup-images {
      position: relative;
      display: flex;
      align-items: center;
      justify-content: center;
    }
    #popup-main-image {
      max-width: 80%;
      max-height: 70vh;
      object-fit: contain;
    }
    .nav-button {
      position: absolute;
      top: 50%;
      transform: translateY(-50%);
      background: rgba(0, 0, 0, 0.7);
      color: white;
      border: none;
      padding: 15px 10px;
      cursor: pointer;
      font-size: 18px;
      border-radius: 5px;
      transition: background 0.3s;
    }
    .nav-button:hover {
      background: rgba(0, 0, 0, 0.9);
    }
    .nav-button:disabled {
      background: rgba(0, 0, 0, 0.3);
      cursor: not-allowed;
    }
    #prev-button {
      left: 10px;
    }
    #next-button {
      right: 10px;
    }
    #close-button {
      position: absolute;
      top: 10px;
      right: 10px;
      background: rgba(0, 0, 0, 0.7);
      color: white;
      border: none;
      padding: 5px 10px;
      cursor: pointer;
      border-radius: 3px;
    }
    #image-counter {
      position: absolute;
      bottom: 10px;
      left: 50%;
      transform: translateX(-50%);
      background: rgba(0, 0, 0, 0.7);
      color: white;
      padding: 5px 10px;
      border-radius: 3px;
      font-size: 14px;
    }
  </style>
</head>
<body>
  <h1>Image Gallery</h1>
  <div id="image-list">
    {% for image in images %}
      <img src="/static/images/{{ image.filename }}" width="100" onclick="showSimilar('{{ image.filename }}')">
    {% endfor %}
  </div>

  <!-- 팝업 오버레이 -->
  <div id="popup-overlay" onclick="closePopup()">
    <div id="popup-content" onclick="event.stopPropagation()">
      <button id="close-button" onclick="closePopup()">×</button>
      <h3>Similar Images</h3>
      <div id="popup-images">
        <button id="prev-button" class="nav-button" onclick="navigateImage(-1)">‹</button>
        <img id="popup-main-image" src="">
        <button id="next-button" class="nav-button" onclick="navigateImage(1)">›</button>
        <div id="image-counter"></div>
      </div>
    </div>
  </div>

  <script>
    let currentImages = [];
    let currentIndex = 0;

    async function showSimilar(filename) {
      const res = await fetch('/similar', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ filename })
      });

      if (!res.ok) {
        alert("서버 오류 발생");
        return;
      }

      const data = await res.json();
      currentImages = [filename, ...data];
      currentIndex = 0;
      
      updatePopupImage();
      document.getElementById('popup-overlay').style.display = 'flex';
    }

    function updatePopupImage() {
      const mainImage = document.getElementById('popup-main-image');
      const counter = document.getElementById('image-counter');
      const prevButton = document.getElementById('prev-button');
      const nextButton = document.getElementById('next-button');
      
      mainImage.src = `/static/images/${currentImages[currentIndex]}`;
      counter.textContent = `${currentIndex + 1} / ${currentImages.length}`;
      
      // 버튼 활성화/비활성화
      prevButton.disabled = currentIndex === 0;
      nextButton.disabled = currentIndex === currentImages.length - 1;
    }

    function navigateImage(direction) {
      const newIndex = currentIndex + direction;
      if (newIndex >= 0 && newIndex < currentImages.length) {
        currentIndex = newIndex;
        updatePopupImage();
      }
    }

    function closePopup() {
      document.getElementById('popup-overlay').style.display = 'none';
      currentImages = [];
      currentIndex = 0;
    }

    // 키보드 네비게이션
    document.addEventListener('keydown', function(event) {
      if (document.getElementById('popup-overlay').style.display === 'flex') {
        if (event.key === 'ArrowLeft') {
          navigateImage(-1);
        } else if (event.key === 'ArrowRight') {
          navigateImage(1);
        } else if (event.key === 'Escape') {
          closePopup();
        }
      }
    });
  </script>
</body>
</html>

mongodb 데이터 확인

$ docker exec -it mongo bash
$ mongo -u romeoh -p 'GXXXXX$' --authenticationDatabase admin
$ show dbs
$ use image_db
$ show collections
$ db.image.find().pretty()

python 가상환경 설정

romeoh — Sun, 27 Jul 2025 08:30:18 +0900

virtualenv

$ mkdir project_folder
$ cd project_folder
$ code .
$ python3 -m venv venv
$ source venv/bin/activate
$ (venv) python --version
Python 3.11.2

$ (venv) deactivate

poetry

# poetry 설치
$ curl -sSL https://install.python-poetry.org | python3 -

# poetry 환경설정
$ export PATH="$HOME/.local/bin:$PATH"

$ poetry --version
Poetry (version 2.1.3)

$ mkdir insta-gura
$ cd insta-gura
$ code .

# poetry 초기화
$ poetry init

# 기본 파일 생성
$ touch README.md
$ mkdir insta_gura
$ cd insta_gura
$ touch __init__.py

# poetry 설치
$ poetry install

# 가상공간 설정
$ poetry env info --path
$ source $(poetry env info --path)/bin/activate 
(insta-gura-py3.11) python --version
Python 3.11.2

# 가상환경 종료
$ deactivate

TensorFlow 사진 분류기

romeoh — Sat, 26 Jul 2025 16:15:42 +0900

시나리오

1. Local 맥북프로 M1 Max 실리콘칩에서 '남자', '여자', '고양이', '자동차', '건물' 사진을 학습한다.

2. NAS 콘테이너에 배포한다.

3. NAS에서 특정 폴더에 사진을 넣고, 해당 사진을 추론해서 분류한다.

icrawler 검색엔진에서 사진 크롤링해서 다운로드

icrawler 설치

$ pip install icrawler

crawler.py

from icrawler.builtin import GoogleImageCrawler

# google
google_crawler = GoogleImageCrawler(
    storage={'root_dir': 'download/cats'},
)
google_crawler.crawl(
    keyword='cat',
    max_num=20,
)

실행

$ python crawler.py

남자', '여자', '고양이', '자동차', '건물' 키워드의 사진을 각 200장씩 다운로드 합니다.

이미지 학습

$ pip install tensorflow

train_model.py

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras import layers, models
import os

# data 준비
data_dir = 'dataset'
image_size = (224, 224)
batch_size = 32             # 32장씩 배치로 처리, 1 epoch에 32장씩

# 데이터 증강 및 전처리
datagen = ImageDataGenerator(
    rescale=1./255,         # 픽셀 값을 0-1 사이로 정규화
    validation_split=0.2    # 20%를 검증 데이터로 분할
)

# 데이터 로드 및 증강 설정
train_data = datagen.flow_from_directory(
    data_dir,
    target_size=image_size,
    batch_size=batch_size,
    class_mode='categorical',   # 다중 클래스 분류를 위한 categorical
    subset='training',
    shuffle=True
)

val_data = datagen.flow_from_directory(
    data_dir,
    target_size=image_size,
    batch_size=batch_size,
    class_mode='categorical',
    subset='validation'
)

# 모델 정의 전이학습
base_model = MobileNetV2(
    input_shape=(224, 224, 3),  # 입력 이미지 크기
    include_top=False,          # 최상위 레이어 제외
    weights='imagenet'          # ImageNet 가중치로 초기화
)
base_model.trainable = False    # 전이학습을 위해 기본 모델의 가중치 동결

# 모델 구성
model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),        # 전역 평균 풀링 레이어 (7,7,512) feaure로 변환
    layers.Dense(128, activation='relu'),   # 완전 연결 레이어
    layers.Dense(5, activation='softmax')   # 클래스 수에 맞춰 출력 레이어 (예: 5개 클래스 분류용)
])

# 모델 컴파일
model.compile(
    optimizer='adam',                   # Adam 옵티마이저 사용
    loss='categorical_crossentropy',    # 다중 클래스 분류를 위한 손실 함수
    metrics=['accuracy']                # 정확도 메트릭 사용
)

# 모델 학습
model.fit(
    train_data,                 # 학습 데이터
    validation_data=val_data,   # 검증 데이터
    epochs=10                   # 에폭 수 (10회 반복 학습)
)

# 모델 저장
model.save('modlel_image_classifier.h5')
print("모델 학습 완료 및 저장됨: model_image_classifier.h5")

$ python train_model.py

...
Epoch 2/10
13/13 ━━━━━━━━━━━━━━━━━━━━ 15s 1s/step - accuracy: 0.9617 - loss: 0.1076 - val_accuracy: 0.9588 - val_loss: 0.1543
Epoch 3/10
13/13 ━━━━━━━━━━━━━━━━━━━━ 15s 1s/step - accuracy: 0.9872 - loss: 0.0370 - val_accuracy: 0.9691 - val_loss: 0.1234
...

데이터 추론

app.py

from flask import Flask, request, jsonify
import tensorflow as tf
from PIL import Image
import numpy as np
import os

app = Flask(__name__)
model = tf.keras.models.load_model('modlel_image_classifier.h5')
class_names = ['building', 'car', 'cats', 'female', 'male']

def predict_image(image_path):
    img = Image.open(image_path).resize((224, 224))
    arr = np.array(img) / 255.0             # 픽셀 값을 0-1 사이로 정규화 (크기: (224, 224, 3))
    arr = np.expand_dims(arr, axis=0)       # 배치 차원 추가 (1, 224, 224, 3)
    pred = model.predict(arr)               # 예측 수행 [0.02, 0.87, 0.11, ...]
    return class_names[np.argmax(pred)]     # 가장 높은 확률의 클래스 이름 반환

@app.route('/classify', methods=['POST'])
def classify():
    file = request.files['image']
    path = f'/tmp/{file.filename}'
    file.save(path)
    label = predict_image(path)
    os.remove(path)
    return jsonify({'label': label})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=6000)

폴더 실시간 감시

watch.py

import time
import os
import shutil
import requests
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

WATCHED_FOLDER = './incoming'
SROTED_FOLDER = './sorted'
API_URL = 'http://localhost:6000/classify'

class ImageHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            return

        if event.src_path.lower().endswith(('.png', '.jpg', '.jpeg')):
            time.sleep(0.5)
            fname = os.path.basename(event.src_path)
            print(f'[이미지 감지] 새 이미지: {fname}')
            
            try:
                with open(event.src_path, 'rb') as f:
                    res = requests.post(API_URL, files={'image': f})
                    label = res.json()['label']
            except Exception as e:
                print(f'[오류] {fname} 이미지 분류 실패: {e}')
                return 
            
            dst_dir = os.path.join(SROTED_FOLDER, label)
            os.makedirs(dst_dir, exist_ok=True)
            
            dst_path = os.path.join(dst_dir, fname)
            shutil.move(event.src_path, dst_path)
            print(f'[이미지 분류 완료] {fname} -> {label}/')

if __name__ == "__main__":
    os.makedirs(WATCHED_FOLDER, exist_ok=True)
    os.makedirs(SROTED_FOLDER, exist_ok=True)

    event_handler = ImageHandler()
    observers = Observer()
    observers.schedule(event_handler, path=WATCHED_FOLDER, recursive=False)
    observers.start()

    print('[감시 시작] 이미지 폴더:', WATCHED_FOLDER)

    try: 
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observers.stop()
    observers.join()

# flask 구동
$ python app.py

# watch 구동
$ python watch.py

[이미지 감지] 새 이미지: IMG_7203.jpeg
[이미지 분류 완료] IMG_7203.jpeg -> cats/
[이미지 감지] 새 이미지: 00008-1037234980.png
[이미지 분류 완료] 00008-1037234980.png -> female/

Synology NAS에 python flask 웹서버 구축

romeoh — Fri, 18 Jul 2025 13:00:41 +0900

SSH활성화

ssh 접속

$ ssh romeoh@192.168.0.XX

Docker 설치

로컬에 파일 생성

$ mkdir flask-app
$ cd flask-app
$ touch app.py
$ touch requirements.txt
$ touch Dockerfile

app.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello NAS!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

requirements.txt

flask

Dockerfile

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["python", "app.py"]

파일을 Synology에 업로드 합니다.

Docker 실행

$ sudo docker build -t flask-app .
$ sudo docker run -d -p 8888:5000 --name flask-test flask-app

# static 폴더 제외하기
$ sudo docker run -d \
  --name flask-app \
  --link mongo \
  -v /volume3/docker/flask-app/static:/app/static \
  -p 8888:5001 \
  flask-app

# container 제거
$ sudo docker ps
$ sudo docker stop flask-test
$ sudo docker rm flask-test

http://192.168.0.16:8888/

접속합니다.

git 서버 구축하기

git 초기화

$ git init

서버에서 커밋하기

# 외부 push 허용
$ git config receive.denyCurrentBranch updateInstead

$ git config user.name "romeoh"
$ git config user.email "romeoh@naver.com"
$ git add .
$ git commit -m "initial commit"

git clone

local에 생성했던 flask-app 폴더는 삭제합니다.

$ cd PROJECT_FOLDER
$ git clone ssh://romeoh@192.168.0.16:/volume3/docker/flask-app

MongoDB설치

$ cd docker
$ mkdir mongodb
$ cd mongodb
$ mkdir data
$ sudo chmod -R 777 /volume3/docker/mongodb/data

$ sudo docker run -d \
  --name mongo \
  -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=secret123 \
  -v /volume3/docker/mongodb/data:/data/db \
  mongo:4.4
  
  $ sudo docker ps

docker 명령어

# 현재 docker 컨테이너 확인
$ sudo docker ps -a

# 콘테이너 정지
$ sudo docker rm mongo

# 콘테이너 로그 확인
$ sudo docker logs mongo

# 콘테이너 내부 진입
$ docker exec -it mongo bash

local에서 flask 서버 구동

가상공간 만들기

$ python3 --version
Python 3.11.2
$ python3 -m venv venv
$ source venv/bin/activate
(venv) romeoh@romeoh-MacBook-Pro flask-app %
(venv) $ pip install -r requirements.txt
(venv) $ python app.py

http://127.0.0.1:5001/

local server 접속

flask에서 mongodb 접속

$ pip install pymongo
$ pip freeze > requirements.txt

FastAPI 서버 구축

romeoh — Mon, 19 May 2025 10:30:51 +0900

버전확인

$ python3 --version
Python 3.11.2

가상환경구축

$ python3 -m venv myproject
$ source myproject/bin/activate    ## 가상환경 진입
$ deactivate                       ## 가상환경 종료

fastapi 설치

$ pip install fastapi uvicorn

Uvicorn: fastapi 실행도구

코드작성

$ cd myproject
$ touch main.py

main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def road_root():
  return {"message": "Hello, FastAPI!"}

서버실행

$ uvicorn main:app --reload

브라우저 접속

http://localhost:8000/

Swagger 문서

http://localhost:8000/docs

router 설정

$ mkdir routers
$ touch routers/users.py

main.py

from fastapi import FastAPI
from routers import users

app = FastAPI()

app.include_router(users.router)

users.py

from fastapi import APIRouter

router = APIRouter(
  prefix="/users",
  tags=["users"],
)

@router.get("/")
def get_users():
  return [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]

@router.get("/{user_id}")
def get_user(user_id: int):
  return {"id": user_id, "name": f"User{user_id}"}

http://localhost:8000/users/

http://localhost:8000/users/2

Swagger 문서

http://localhost:8000/docs

Pydantic 설정

$ mkdir schemas
$ touch schemas/user.py

schemas/user.py

# schemas/user.py
from pydantic import BaseModel

class User(BaseModel):
  id: int
  name: str

routers/users.py

from fastapi import APIRouter
from typing import List
from schemas.user import User

router = APIRouter(
  prefix="/users",
  tags=["users"],
)

@router.get("/", response_model=List[User])
def get_users():
  return [
    {"id": 1, "name": "Alice"}, 
    {"id": 2, "name": "Bob"}
  ]

@router.get("/{user_id}", response_model=User)
def get_user(user_id: int):
  return {"id": user_id, "name": f"User{user_id}"}

iOS 앱스토어 배포하기

romeoh — Fri, 22 Nov 2024 22:25:58 +0900

iOS를 배포하기 위해 앱정보와 가격 등 필요한 모든 정보를 입력하고

마지막으로 빌드를 업로드 합니다.

Xcode로 빌드를 업로드하겠습니다.

Xcode에서 Team과 Bundle Identifier를 확인합니다.

Edit Scheme...를 선태합니다.

version과 build를 설정합니다.

Product > Archive를 선택합니다.

version과 build를 선택하고 Distribute App을 누릅니다.

App Store Connect를 선택하고 Distribute 합니다.

업로드가 완성되었습니다.

Flutter in app 결제 구현

romeoh — Fri, 22 Nov 2024 16:17:15 +0900

iOS 상품 생성

https://appstoreconnect.apple.com/apps

앱을 선택합니다.

신규 앱을 생성합니다.

앱을 생성합니다.

국가를 선택합니다.

가격을 설정합니다.

현지화를 추가합니다.

iOS Sandbox 계정생성

iOS in app purchase 상품 불러오기

$ flutter pub add in_app_purchase

import 'package:flutter/material.dart';
import 'package:in_app_purchase/in_app_purchase.dart';

class ProductListScreen extends StatefulWidget {
  @override
  _ProductListScreenState createState() => _ProductListScreenState();
}

class _ProductListScreenState extends State<ProductListScreen> {
  final InAppPurchase _inAppPurchase = InAppPurchase.instance;
  bool _available = true;
  List<ProductDetails> _products = [];
  
  // 상품 ID 목록
  final Set<String> _productIds = {'product_id_1', 'product_id_2', 'product_id_3'};

  @override
  void initState() {
    super.initState();
    _initialize();
  }

  Future<void> _initialize() async {
    // 인앱 구매가 가능한지 확인
    final bool isAvailable = await _inAppPurchase.isAvailable();
    setState(() {
      _available = isAvailable;
    });
    if (isAvailable) {
      await _loadProducts();
    }
  }

  Future<void> _loadProducts() async {
    // 상품 정보를 요청
    final ProductDetailsResponse response = await _inAppPurchase.queryProductDetails(_productIds);

    // 요청한 상품 중 없는 상품이 있으면 처리
    if (response.notFoundIDs.isNotEmpty) {
      print("다음 상품 ID를 찾을 수 없습니다: ${response.notFoundIDs}");
      return;
    }
    
    // 요청 성공 시 상품 정보 저장
    setState(() {
      _products = response.productDetails;
    });
  }

  @override
  void dispose() {
    _inAppPurchase.purchaseStream.drain();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Available Products'),
      ),
      body: _available
          ? _products.isNotEmpty
              ? ListView.builder(
                  itemCount: _products.length,
                  itemBuilder: (context, index) {
                    final product = _products[index];
                    return ListTile(
                      title: Text(product.title),
                      subtitle: Text(product.description),
                      trailing: Text(product.price),
                    );
                  },
                )
              : Center(child: Text('상품을 불러오는 중...'))
          : Center(child: Text('인앱 구매를 사용할 수 없습니다.')),
    );
  }
}

이 상태로 실행해보면 인앱 상품을 읽어오지 못합니다.

인앱 상품을 불러오기 위해서는 인앱 상품을 심사 통과해야 합니다.

그러기 위해서 이미지와 스크린샷을 찍고, 앱을 제출해야 합니다.

인앱 상품을 불러오지 못하는데, 어떻게 스크린샷을 찍냐?

그냥 상품은 하드코딩해서 표시만 해서 스크린샷을 찍습니다.

그리고 심사용 추가정보에 심사를 위해 필요한(로그인 아이디/비번 등) 정보를 표기해서 제출합니다.

심사가 통과되면 첫번째 버전의 앱은 출시하지말고,

인앱 상품을 불러와서 완성하여 차기 버전을 다시 제출하고 통과후 출시합니다.

(GR 같습니다.)

앱 배포 준비가 되면 입 내 구입 또는 구독이 하기 버튼을 누릅니다.

심사에 제출하기로 마무리합니다.