965 lines
34 KiB
Markdown
965 lines
34 KiB
Markdown
# POST /api/train/status/{uuid} - 상태 전이 다이어그램 완전 가이드
|
||
|
||
> **프론트엔드 표시 방법 및 상태 제어 API 포함**
|
||
|
||
---
|
||
|
||
## 📊 1. DB 테이블 상태 필드
|
||
|
||
### 1.1 **Job 테이블** (`tb_model_train_job`)
|
||
| 필드명 | 설명 | 가능한 값 | UI 표시명 |
|
||
|--------|------|-----------|-----------|
|
||
| `status_cd` | Job 실행 상태 | `QUEUED`, `RUNNING`, `SUCCESS`, `FAILED`, `STOPPED`, `CANCELED` | 대기중, 실행중, 성공, 실패, 중단됨, 취소 |
|
||
| `exit_code` | 종료 코드 | 정수 (0: 정상, -1: 중단, 기타: 에러) | - |
|
||
| `error_message` | 에러 메시지 | 문자열 | 에러 상세 내용 |
|
||
| `finished_dttm` | 완료 시간 | timestamp | YYYY-MM-DD HH:mm:ss |
|
||
|
||
### 1.2 **Model Master 테이블** (`tb_model_master`)
|
||
| 필드명 | 설명 | 가능한 값 | UI 표시명 |
|
||
|--------|------|-----------|-----------|
|
||
| `status_cd` | 전체 모델 상태 | `READY`, `IN_PROGRESS`, `COMPLETED`, `STOPPED`, `ERROR` | 대기, 진행중, 완료, 중단됨, 오류 |
|
||
| `step1_state` | Step1(학습) 상태 | `READY`, `IN_PROGRESS`, `COMPLETED`, `STOPPED`, `ERROR` | 대기, 진행중, 완료, 중단됨, 오류 |
|
||
| `step2_state` | Step2(테스트) 상태 | `READY`, `IN_PROGRESS`, `COMPLETED`, `STOPPED`, `ERROR` | 대기, 진행중, 완료, 중단됨, 오류 |
|
||
| `step1_strt_dttm` | Step1 시작 시간 | timestamp | YYYY-MM-DD HH:mm:ss |
|
||
| `step1_end_dttm` | Step1 종료 시간 | timestamp | YYYY-MM-DD HH:mm:ss |
|
||
| `step2_strt_dttm` | Step2 시작 시간 | timestamp | YYYY-MM-DD HH:mm:ss |
|
||
| `step2_end_dttm` | Step2 종료 시간 | timestamp | YYYY-MM-DD HH:mm:ss |
|
||
| `step1_metric_save_yn` | Step1 메트릭 저장 여부 | `true`, `false` | - |
|
||
| `step2_metric_save_yn` | Step2 메트릭 저장 여부 | `true`, `false` | - |
|
||
| `current_attempt_id` | 현재 실행 중인 Job ID | Long | - |
|
||
| `best_epoch` | 최적 에폭 | Integer | Best Epoch: {값} |
|
||
| `last_error` | 마지막 에러 메시지 | 문자열 | 에러 상세 내용 |
|
||
|
||
---
|
||
|
||
## 🎨 2. 프론트엔드 API 응답 및 표시
|
||
|
||
### 2.1 모델 목록 조회 API
|
||
|
||
**엔드포인트**: `GET /api/models/list`
|
||
|
||
**요청 파라미터**:
|
||
```json
|
||
{
|
||
"status": "IN_PROGRESS", // "", "IN_PROGRESS", "COMPLETED"
|
||
"modelNo": "G1", // "G1", "G2", "G3", "G4"
|
||
"page": 0,
|
||
"size": 20
|
||
}
|
||
```
|
||
|
||
**응답 예시**:
|
||
```json
|
||
{
|
||
"success": true,
|
||
"data": {
|
||
"content": [
|
||
{
|
||
"id": 123,
|
||
"uuid": "e22181eb-2ac4-4100-9941-d06efce25c49",
|
||
"modelVer": "v1.0.0",
|
||
"statusCd": "IN_PROGRESS",
|
||
"statusName": "진행중",
|
||
"step1Status": "COMPLETED",
|
||
"step1StatusName": "완료",
|
||
"step2Status": "IN_PROGRESS",
|
||
"step2StatusName": "진행중",
|
||
"step1StrtDttm": "2026-04-05 10:30:00",
|
||
"step1EndDttm": "2026-04-05 12:45:00",
|
||
"step1Duration": "2시간 15분 0초",
|
||
"step2StrtDttm": "2026-04-05 12:50:00",
|
||
"step2EndDttm": null,
|
||
"step2Duration": null,
|
||
"modelNo": "G1",
|
||
"trainType": "GENERAL",
|
||
"trainTypeName": "일반",
|
||
"currentAttemptId": 456,
|
||
"memo": "테스트 학습"
|
||
}
|
||
],
|
||
"totalElements": 100,
|
||
"totalPages": 5
|
||
}
|
||
}
|
||
```
|
||
|
||
### 2.2 프론트엔드 표시 예시
|
||
|
||
#### 📋 **모델 목록 테이블**
|
||
|
||
| 모델 번호 | 버전 | 전체 상태 | 학습(Step1) | 테스트(Step2) | 학습 시간 | 테스트 시간 | 작업 |
|
||
|----------|------|----------|------------|------------|----------|----------|------|
|
||
| G1 | v1.0.0 | 🟢 진행중 | ✅ 완료 (2시간 15분) | 🔄 진행중 | 2026-04-05 10:30 ~ 12:45 | 2026-04-05 12:50 ~ | [취소] |
|
||
| G2 | v1.0.1 | ✅ 완료 | ✅ 완료 (1시간 30분) | ✅ 완료 (45분) | 2026-04-04 14:00 ~ 15:30 | 2026-04-04 15:35 ~ 16:20 | [결과보기] |
|
||
| G3 | v1.0.2 | ⚠️ 중단됨 | ⚠️ 중단됨 | - | 2026-04-03 09:00 ~ | - | [재시작] [이어하기] |
|
||
| G4 | v1.0.3 | ❌ 오류 | ❌ 오류 | - | 2026-04-02 11:00 ~ | - | [재시작] |
|
||
|
||
#### 🎯 **상태별 UI 컬러 가이드**
|
||
|
||
```javascript
|
||
// 상태별 배지 색상 매핑
|
||
const STATUS_COLORS = {
|
||
'READY': { bg: '#e3f2fd', text: '#1976d2', icon: '⏸️' }, // 파란색 - 대기
|
||
'IN_PROGRESS': { bg: '#e8f5e9', text: '#388e3c', icon: '🔄' }, // 녹색 - 진행중
|
||
'COMPLETED': { bg: '#f1f8e9', text: '#689f38', icon: '✅' }, // 연두색 - 완료
|
||
'STOPPED': { bg: '#fff3e0', text: '#f57c00', icon: '⚠️' }, // 주황색 - 중단됨
|
||
'ERROR': { bg: '#ffebee', text: '#d32f2f', icon: '❌' } // 빨간색 - 오류
|
||
};
|
||
|
||
// 상태명 한글 변환
|
||
const STATUS_NAMES = {
|
||
'READY': '대기',
|
||
'IN_PROGRESS': '진행중',
|
||
'COMPLETED': '완료',
|
||
'STOPPED': '중단됨',
|
||
'ERROR': '오류'
|
||
};
|
||
|
||
// React 컴포넌트 예시
|
||
function StatusBadge({ statusCd }) {
|
||
const { bg, text, icon } = STATUS_COLORS[statusCd] || {};
|
||
const name = STATUS_NAMES[statusCd] || statusCd;
|
||
|
||
return (
|
||
<span style={{ backgroundColor: bg, color: text, padding: '4px 12px', borderRadius: '12px' }}>
|
||
{icon} {name}
|
||
</span>
|
||
);
|
||
}
|
||
```
|
||
|
||
#### 📊 **상세 진행 상황 표시**
|
||
|
||
```javascript
|
||
// Step별 진행률 계산
|
||
function ModelProgressBar({ model }) {
|
||
const steps = [
|
||
{
|
||
name: '학습 (Step1)',
|
||
status: model.step1Status,
|
||
statusName: model.step1StatusName,
|
||
startTime: model.step1StrtDttm,
|
||
endTime: model.step1EndDttm,
|
||
duration: model.step1Duration
|
||
},
|
||
{
|
||
name: '테스트 (Step2)',
|
||
status: model.step2Status,
|
||
statusName: model.step2StatusName,
|
||
startTime: model.step2StrtDttm,
|
||
endTime: model.step2EndDttm,
|
||
duration: model.step2Duration
|
||
}
|
||
];
|
||
|
||
return (
|
||
<div className="progress-container">
|
||
{steps.map((step, index) => (
|
||
<div key={index} className="step-item">
|
||
<div className="step-header">
|
||
<span className="step-name">{step.name}</span>
|
||
<StatusBadge statusCd={step.status} />
|
||
</div>
|
||
<div className="step-time">
|
||
{step.startTime && (
|
||
<>
|
||
<span>시작: {step.startTime}</span>
|
||
{step.endTime && <span> ~ 종료: {step.endTime}</span>}
|
||
{step.duration && <span> (소요시간: {step.duration})</span>}
|
||
</>
|
||
)}
|
||
</div>
|
||
{step.status === 'IN_PROGRESS' && (
|
||
<div className="loading-bar">
|
||
<div className="loading-animation"></div>
|
||
</div>
|
||
)}
|
||
</div>
|
||
))}
|
||
</div>
|
||
);
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 🔄 3. 상태 전이 플로우차트 (상태값 명시)
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ POST /api/train/status/{uuid} API 호출 │
|
||
└────────────────────────────┬────────────────────────────────────┘
|
||
↓
|
||
┌────────────────────┐
|
||
│ UUID → ModelID │
|
||
│ 조회 및 Job 조회 │
|
||
└────────┬───────────┘
|
||
↓
|
||
┌────────────────────┐
|
||
│ Docker Inspect 실행 │
|
||
│ (containerName) │
|
||
└────────┬───────────┘
|
||
↓
|
||
┌──────────────┴──────────────┐
|
||
│ │
|
||
[exists=false] [exists=true]
|
||
컨테이너 없음 컨테이너 존재
|
||
↓ ↓
|
||
┌─────────────────────┐ ┌──────────────────────┐
|
||
│ TrainUtilService │ │ jobType 확인 │
|
||
│ .probeOutputs() │ │ (paramsJson) │
|
||
│ │ └──────────┬───────────┘
|
||
│ 1. total_epoch 추출 │ │
|
||
│ 2. valInterval 추출 │ ┌──────────┴──────────┐
|
||
│ 3. val.csv 존재확인 │ │ │
|
||
│ 4. 라인수 검증 │ [TRAIN] [EVAL]
|
||
└─────────┬───────────┘ │ │
|
||
│ ↓ ↓
|
||
┌─────────┴─────────┐ ┌──────────────┐ ┌──────────────┐
|
||
│ │ │ Step1 진행중 │ │ Step2 진행중 │
|
||
[completed=true] [completed=false] └──────────────┘ └──────────────┘
|
||
│ │ │ │
|
||
│ │ ┌────▼─────────────────────▼────────┐
|
||
│ │ │ ✅ tb_model_train_job │
|
||
│ │ │ status_cd = "RUNNING" │
|
||
│ │ │ │
|
||
│ │ │ ✅ tb_model_master │
|
||
│ │ │ status_cd = "IN_PROGRESS" │
|
||
│ │ │ step1_state = "IN_PROGRESS" │ [TRAIN]
|
||
│ │ │ step1_strt_dttm = now() │
|
||
│ │ │ OR │
|
||
│ │ │ step2_state = "IN_PROGRESS" │ [EVAL]
|
||
│ │ │ step2_strt_dttm = now() │
|
||
│ │ │ current_attempt_id = jobId │
|
||
│ │ └──────────────────────────────────┘
|
||
│ │ 【프론트 표시】
|
||
│ │ 🔄 진행중 - 학습 중... / 테스트 중...
|
||
│ │
|
||
│ ↓
|
||
│ ┌─────────────────────┐
|
||
│ │ ⚠️ 산출물 부족 │
|
||
│ │ (val.csv 부족 등) │
|
||
│ └─────────┬───────────┘
|
||
│ │
|
||
│ ┌─────────▼────────────────────────────────┐
|
||
│ │ ⚠️ tb_model_train_job │
|
||
│ │ status_cd = "STOPPED" │
|
||
│ │ exit_code = -1 │
|
||
│ │ error_message = "SERVER_RESTART_..." │
|
||
│ │ │
|
||
│ │ ⚠️ tb_model_master │
|
||
│ │ status_cd = "STOPPED" │
|
||
│ │ step1_state = "STOPPED" [TRAIN] │
|
||
│ │ OR │
|
||
│ │ step2_state = "STOPPED" [EVAL] │
|
||
│ │ last_error = "컨테이너 없음, 산출물 부족" │
|
||
│ └──────────────────────────────────────────┘
|
||
│ 【프론트 표시】
|
||
│ ⚠️ 중단됨 - 산출물 부족으로 중단됨
|
||
│ [재시작] [이어하기] 버튼 활성화
|
||
│
|
||
↓
|
||
┌──────────────────┐
|
||
│ existsZipFile() │
|
||
│ ZIP 파일 존재? │
|
||
└────┬────────┬────┘
|
||
│ │
|
||
[YES] [NO]
|
||
│ │
|
||
│ ↓
|
||
│ ┌──────────────────────────────────────────────┐
|
||
│ │ 📁 학습 완료 (Step1만) │
|
||
│ └─────────┬────────────────────────────────────┘
|
||
│ │
|
||
│ ┌─────────▼──────────────────────────────────┐
|
||
│ │ ✅ tb_model_train_job │
|
||
│ │ status_cd = "SUCCESS" │
|
||
│ │ exit_code = 0 │
|
||
│ │ finished_dttm = now() │
|
||
│ │ │
|
||
│ │ ✅ tb_model_master (Step1 미완료 시) │
|
||
│ │ status_cd = "COMPLETED" │
|
||
│ │ step1_state = "COMPLETED" │
|
||
│ │ step1_end_dttm = now() │
|
||
│ │ step1_metric_save_yn = true │
|
||
│ │ │
|
||
│ │ 📊 Metrics 저장 │
|
||
│ │ - train.csv → tb_model_metrics_train │
|
||
│ │ - val.csv → tb_model_metrics_validation │
|
||
│ └────────────────────────────────────────────┘
|
||
│ 【프론트 표시】
|
||
│ ✅ 완료 - 학습 완료 (테스트 대기)
|
||
│ [테스트 실행] 버튼 활성화
|
||
│
|
||
↓
|
||
┌──────────────────────────────────────────────┐
|
||
│ 📦 학습+테스트 완료 (Step1 + Step2) │
|
||
└─────────┬────────────────────────────────────┘
|
||
│
|
||
┌─────────▼──────────────────────────────────┐
|
||
│ ✅ tb_model_train_job │
|
||
│ status_cd = "SUCCESS" │
|
||
│ exit_code = 0 │
|
||
│ finished_dttm = now() │
|
||
│ │
|
||
│ ✅ tb_model_master (Step1 미완료 시) │
|
||
│ status_cd = "COMPLETED" │
|
||
│ step1_state = "COMPLETED" │
|
||
│ step1_end_dttm = now() │
|
||
│ step1_metric_save_yn = true │
|
||
│ │
|
||
│ ✅ tb_model_master (Step2 미완료 시) │
|
||
│ step2_state = "COMPLETED" │
|
||
│ step2_end_dttm = now() │
|
||
│ step2_metric_save_yn = true │
|
||
│ best_epoch = 최적값 │
|
||
│ │
|
||
│ 📊 Metrics 저장 │
|
||
│ - train.csv → tb_model_metrics_train │
|
||
│ - val.csv → tb_model_metrics_validation │
|
||
│ - test.csv → 테스트 메트릭 테이블 │
|
||
│ - *.zip → 테스트 결과 파일 생성 │
|
||
└────────────────────────────────────────────┘
|
||
【프론트 표시】
|
||
✅ 완료 - 모든 학습 및 테스트 완료
|
||
[결과 보기] [다운로드] 버튼 활성화
|
||
```
|
||
|
||
---
|
||
|
||
## 🛠️ 4. 상태 제어 API 목록
|
||
|
||
### 4.1 학습 실행 제어 API
|
||
|
||
| API | HTTP | 엔드포인트 | 설명 | 상태 전환 | 프론트 버튼 표시 조건 |
|
||
|-----|------|-----------|------|----------|---------------------|
|
||
| **학습 실행** | POST | `/api/train/run/{uuid}` | 최초 학습 시작 | `READY` → `IN_PROGRESS` | `statusCd == 'READY'` |
|
||
| **학습 재실행** | POST | `/api/train/restart/{uuid}` | 중단/오류 후 처음부터 재실행 | `STOPPED/ERROR` → `IN_PROGRESS` | `statusCd == 'STOPPED' \|\| statusCd == 'ERROR'` |
|
||
| **학습 이어하기** | POST | `/api/train/resume/{uuid}` | 중단된 지점부터 계속 실행 | `STOPPED` → `IN_PROGRESS` | `statusCd == 'STOPPED'` |
|
||
| **학습 취소** | POST | `/api/train/cancel/{uuid}` | 실행 중인 학습 중단 | `IN_PROGRESS` → `STOPPED` | `statusCd == 'IN_PROGRESS' && step1Status == 'IN_PROGRESS'` |
|
||
| **학습 상태 확인** | POST | `/api/train/status/{uuid}` | 현재 상태 동기화 | 현재 상태 유지/갱신 | 주기적 호출 (폴링) |
|
||
|
||
### 4.2 테스트 실행 제어 API
|
||
|
||
| API | HTTP | 엔드포인트 | 설명 | 상태 전환 | 프론트 버튼 표시 조건 |
|
||
|-----|------|-----------|------|----------|---------------------|
|
||
| **테스트 실행** | POST | `/api/train/test/run/{epoch}/{uuid}` | 특정 에폭으로 테스트 실행 | `step2_state: READY` → `IN_PROGRESS` | `step1Status == 'COMPLETED' && step2Status != 'IN_PROGRESS'` |
|
||
| **테스트 취소** | POST | `/api/train/test/cancel/{uuid}` | 실행 중인 테스트 중단 | `step2_state: IN_PROGRESS` → `STOPPED` | `step2Status == 'IN_PROGRESS'` |
|
||
|
||
### 4.3 기타 API
|
||
|
||
| API | HTTP | 엔드포인트 | 설명 |
|
||
|-----|------|-----------|------|
|
||
| **데이터셋 임시 파일 생성** | POST | `/api/train/create-tmp/{uuid}` | 학습용 임시 데이터셋 생성 |
|
||
| **데이터셋 카운트 조회** | GET | `/api/train/counts/{uuid}` | 데이터셋 통계 정보 조회 |
|
||
|
||
---
|
||
|
||
## 📋 5. 상태별 프론트엔드 액션 매트릭스
|
||
|
||
### 5.1 전체 상태 (`statusCd`) 기준
|
||
|
||
| 상태 코드 | 상태명 | 활성화 버튼 | 비활성화 버튼 | 표시 메시지 | UI 색상 |
|
||
|-----------|-------|------------|--------------|------------|---------|
|
||
| `READY` | 대기 | [학습 실행] | [취소] [재실행] [이어하기] | "학습 준비 완료" | 파란색 |
|
||
| `IN_PROGRESS` | 진행중 | [취소] | [학습 실행] [재실행] [이어하기] | "학습 진행 중..." | 녹색 |
|
||
| `COMPLETED` | 완료 | [결과 보기] [다운로드] | [학습 실행] [취소] | "학습 완료" | 연두색 |
|
||
| `STOPPED` | 중단됨 | [재실행] [이어하기] | [취소] | "학습 중단됨 - 재시작 가능" | 주황색 |
|
||
| `ERROR` | 오류 | [재실행] | [취소] [이어하기] | "오류 발생 - 재시작 필요" | 빨간색 |
|
||
|
||
### 5.2 Step1 상태 (`step1Status`) 기준
|
||
|
||
| 상태 코드 | 버튼/액션 | 조건 | 설명 |
|
||
|-----------|----------|------|------|
|
||
| `READY` | [학습 실행] | `statusCd == 'READY'` | 최초 학습 시작 |
|
||
| `IN_PROGRESS` | [학습 취소] | `statusCd == 'IN_PROGRESS'` | 진행 중인 학습 중단 |
|
||
| `COMPLETED` | [테스트 실행] | `step2Status == 'READY'` | 학습 완료 후 테스트 가능 |
|
||
| `STOPPED` | [재실행] [이어하기] | `statusCd == 'STOPPED'` | 중단된 학습 복구 |
|
||
| `ERROR` | [재실행] | `statusCd == 'ERROR'` | 오류 발생 후 재시도 |
|
||
|
||
### 5.3 Step2 상태 (`step2Status`) 기준
|
||
|
||
| 상태 코드 | 버튼/액션 | 조건 | 설명 |
|
||
|-----------|----------|------|------|
|
||
| `READY` | [테스트 실행] | `step1Status == 'COMPLETED'` | 학습 완료 후 테스트 가능 |
|
||
| `IN_PROGRESS` | [테스트 취소] | `statusCd == 'IN_PROGRESS'` | 진행 중인 테스트 중단 |
|
||
| `COMPLETED` | [결과 보기] [다운로드] | 항상 | 테스트 완료 후 결과 확인 |
|
||
| `STOPPED` | [테스트 재실행] | `step1Status == 'COMPLETED'` | 중단된 테스트 재시작 |
|
||
|
||
---
|
||
|
||
## 💻 6. 프론트엔드 구현 예시
|
||
|
||
### 6.1 상태별 버튼 렌더링 (React)
|
||
|
||
```javascript
|
||
function ModelActionButtons({ model }) {
|
||
const { uuid, statusCd, step1Status, step2Status } = model;
|
||
|
||
// 학습 실행 버튼
|
||
const canRun = statusCd === 'READY';
|
||
|
||
// 학습 취소 버튼
|
||
const canCancel = statusCd === 'IN_PROGRESS' && step1Status === 'IN_PROGRESS';
|
||
|
||
// 재실행 버튼
|
||
const canRestart = ['STOPPED', 'ERROR'].includes(statusCd);
|
||
|
||
// 이어하기 버튼
|
||
const canResume = statusCd === 'STOPPED';
|
||
|
||
// 테스트 실행 버튼
|
||
const canTest = step1Status === 'COMPLETED' &&
|
||
step2Status !== 'IN_PROGRESS' &&
|
||
step2Status !== 'COMPLETED';
|
||
|
||
// 테스트 취소 버튼
|
||
const canCancelTest = step2Status === 'IN_PROGRESS';
|
||
|
||
// 결과 보기 버튼
|
||
const canViewResult = statusCd === 'COMPLETED' &&
|
||
step1Status === 'COMPLETED' &&
|
||
step2Status === 'COMPLETED';
|
||
|
||
return (
|
||
<div className="action-buttons">
|
||
{canRun && (
|
||
<button onClick={() => runTrain(uuid)} className="btn-primary">
|
||
🚀 학습 실행
|
||
</button>
|
||
)}
|
||
|
||
{canCancel && (
|
||
<button onClick={() => cancelTrain(uuid)} className="btn-danger">
|
||
⏹️ 학습 취소
|
||
</button>
|
||
)}
|
||
|
||
{canRestart && (
|
||
<button onClick={() => restartTrain(uuid)} className="btn-warning">
|
||
🔄 재실행
|
||
</button>
|
||
)}
|
||
|
||
{canResume && (
|
||
<button onClick={() => resumeTrain(uuid)} className="btn-info">
|
||
▶️ 이어하기
|
||
</button>
|
||
)}
|
||
|
||
{canTest && (
|
||
<button onClick={() => runTest(uuid, model.bestEpoch)} className="btn-success">
|
||
🧪 테스트 실행
|
||
</button>
|
||
)}
|
||
|
||
{canCancelTest && (
|
||
<button onClick={() => cancelTest(uuid)} className="btn-danger">
|
||
⏹️ 테스트 취소
|
||
</button>
|
||
)}
|
||
|
||
{canViewResult && (
|
||
<button onClick={() => viewResult(uuid)} className="btn-primary">
|
||
📊 결과 보기
|
||
</button>
|
||
)}
|
||
</div>
|
||
);
|
||
}
|
||
```
|
||
|
||
### 6.2 API 호출 함수
|
||
|
||
```javascript
|
||
import axios from 'axios';
|
||
|
||
const API_BASE = '/api/train';
|
||
|
||
// 학습 실행
|
||
async function runTrain(uuid) {
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/run/${uuid}`);
|
||
if (response.data.success) {
|
||
alert('학습이 시작되었습니다.');
|
||
refreshModelList(); // 목록 갱신
|
||
}
|
||
} catch (error) {
|
||
alert('학습 실행 실패: ' + error.message);
|
||
}
|
||
}
|
||
|
||
// 학습 취소
|
||
async function cancelTrain(uuid) {
|
||
if (!confirm('학습을 취소하시겠습니까?')) return;
|
||
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/cancel/${uuid}`);
|
||
if (response.data.success) {
|
||
alert('학습이 취소되었습니다.');
|
||
refreshModelList();
|
||
}
|
||
} catch (error) {
|
||
alert('학습 취소 실패: ' + error.message);
|
||
}
|
||
}
|
||
|
||
// 학습 재실행
|
||
async function restartTrain(uuid) {
|
||
if (!confirm('처음부터 다시 학습을 시작하시겠습니까?')) return;
|
||
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/restart/${uuid}`);
|
||
if (response.data.success) {
|
||
alert('학습이 재시작되었습니다.');
|
||
refreshModelList();
|
||
}
|
||
} catch (error) {
|
||
alert('학습 재시작 실패: ' + error.message);
|
||
}
|
||
}
|
||
|
||
// 학습 이어하기
|
||
async function resumeTrain(uuid) {
|
||
if (!confirm('중단된 지점부터 학습을 이어가시겠습니까?')) return;
|
||
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/resume/${uuid}`);
|
||
if (response.data.success) {
|
||
alert('학습이 재개되었습니다.');
|
||
refreshModelList();
|
||
}
|
||
} catch (error) {
|
||
alert('학습 이어하기 실패: ' + error.message);
|
||
}
|
||
}
|
||
|
||
// 테스트 실행
|
||
async function runTest(uuid, epoch) {
|
||
if (!confirm(`Epoch ${epoch}으로 테스트를 실행하시겠습니까?`)) return;
|
||
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/test/run/${epoch}/${uuid}`);
|
||
if (response.data.success) {
|
||
alert('테스트가 시작되었습니다.');
|
||
refreshModelList();
|
||
}
|
||
} catch (error) {
|
||
alert('테스트 실행 실패: ' + error.message);
|
||
}
|
||
}
|
||
|
||
// 테스트 취소
|
||
async function cancelTest(uuid) {
|
||
if (!confirm('테스트를 취소하시겠습니까?')) return;
|
||
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/test/cancel/${uuid}`);
|
||
if (response.data.success) {
|
||
alert('테스트가 취소되었습니다.');
|
||
refreshModelList();
|
||
}
|
||
} catch (error) {
|
||
alert('테스트 취소 실패: ' + error.message);
|
||
}
|
||
}
|
||
|
||
// 학습 상태 확인 (폴링용)
|
||
async function checkTrainStatus(uuid) {
|
||
try {
|
||
const response = await axios.post(`${API_BASE}/status/${uuid}`);
|
||
return response.data.success;
|
||
} catch (error) {
|
||
console.error('상태 확인 실패:', error);
|
||
return false;
|
||
}
|
||
}
|
||
```
|
||
|
||
### 6.3 주기적 상태 업데이트 (폴링)
|
||
|
||
```javascript
|
||
import { useEffect, useState } from 'react';
|
||
|
||
function ModelMonitor({ uuid }) {
|
||
const [isPolling, setIsPolling] = useState(false);
|
||
|
||
useEffect(() => {
|
||
let intervalId;
|
||
|
||
// 진행 중인 모델만 폴링
|
||
if (isPolling) {
|
||
intervalId = setInterval(async () => {
|
||
const success = await checkTrainStatus(uuid);
|
||
if (success) {
|
||
refreshModelList(); // 상태 업데이트 후 목록 갱신
|
||
}
|
||
}, 10000); // 10초마다 상태 확인
|
||
}
|
||
|
||
return () => {
|
||
if (intervalId) clearInterval(intervalId);
|
||
};
|
||
}, [uuid, isPolling]);
|
||
|
||
// 모델 상태에 따라 폴링 활성화/비활성화
|
||
useEffect(() => {
|
||
const shouldPoll = model.statusCd === 'IN_PROGRESS';
|
||
setIsPolling(shouldPoll);
|
||
}, [model.statusCd]);
|
||
|
||
return null; // 백그라운드 작업
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 🎯 7. 상태 수정 시나리오별 가이드
|
||
|
||
### 시나리오 1: 학습 중단 후 재시작
|
||
|
||
**현재 상태**:
|
||
```json
|
||
{
|
||
"statusCd": "STOPPED",
|
||
"step1Status": "STOPPED",
|
||
"lastError": "SERVER_RESTART_CONTAINER_MISSING_OUTPUT_INCOMPLETE"
|
||
}
|
||
```
|
||
|
||
**프론트 표시**:
|
||
- ⚠️ 중단됨 - 산출물 부족으로 중단됨
|
||
- 버튼: [재실행] [이어하기]
|
||
|
||
**액션**:
|
||
|
||
**옵션 A) 재실행** (`POST /api/train/restart/{uuid}`):
|
||
```javascript
|
||
// 처음부터 다시 시작
|
||
await axios.post(`/api/train/restart/${uuid}`);
|
||
|
||
// 결과 상태
|
||
{
|
||
"statusCd": "IN_PROGRESS",
|
||
"step1Status": "IN_PROGRESS",
|
||
"currentAttemptId": 새로운JobId
|
||
}
|
||
```
|
||
|
||
**옵션 B) 이어하기** (`POST /api/train/resume/{uuid}`):
|
||
```javascript
|
||
// 중단된 지점부터 계속
|
||
await axios.post(`/api/train/resume/${uuid}`);
|
||
|
||
// 결과 상태
|
||
{
|
||
"statusCd": "IN_PROGRESS",
|
||
"step1Status": "IN_PROGRESS",
|
||
"currentAttemptId": 새로운JobId,
|
||
// paramsJson에 resumeFrom 설정됨
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### 시나리오 2: 학습 완료 후 테스트 실행
|
||
|
||
**현재 상태**:
|
||
```json
|
||
{
|
||
"statusCd": "COMPLETED",
|
||
"step1Status": "COMPLETED",
|
||
"step2Status": "READY",
|
||
"bestEpoch": 45
|
||
}
|
||
```
|
||
|
||
**프론트 표시**:
|
||
- ✅ 완료 - 학습 완료 (테스트 대기)
|
||
- 버튼: [테스트 실행]
|
||
|
||
**액션**:
|
||
```javascript
|
||
// 테스트 실행 (bestEpoch 사용)
|
||
await axios.post(`/api/train/test/run/45/${uuid}`);
|
||
|
||
// 결과 상태
|
||
{
|
||
"statusCd": "IN_PROGRESS",
|
||
"step1Status": "COMPLETED",
|
||
"step2Status": "IN_PROGRESS",
|
||
"step2StrtDttm": "2026-04-06 14:30:00"
|
||
}
|
||
```
|
||
|
||
**프론트 표시 변경**:
|
||
- 🔄 진행중 - 테스트 진행 중...
|
||
- 버튼: [테스트 취소]
|
||
|
||
---
|
||
|
||
### 시나리오 3: 실행 중인 학습 취소
|
||
|
||
**현재 상태**:
|
||
```json
|
||
{
|
||
"statusCd": "IN_PROGRESS",
|
||
"step1Status": "IN_PROGRESS",
|
||
"currentAttemptId": 123
|
||
}
|
||
```
|
||
|
||
**프론트 표시**:
|
||
- 🔄 진행중 - 학습 진행 중...
|
||
- 버튼: [학습 취소]
|
||
|
||
**액션**:
|
||
```javascript
|
||
// 학습 취소
|
||
await axios.post(`/api/train/cancel/${uuid}`);
|
||
|
||
// 결과 상태
|
||
{
|
||
"statusCd": "STOPPED",
|
||
"step1Status": "STOPPED",
|
||
"currentAttemptId": 123
|
||
}
|
||
```
|
||
|
||
**프론트 표시 변경**:
|
||
- ⚠️ 중단됨 - 사용자가 학습을 취소함
|
||
- 버튼: [재실행] [이어하기]
|
||
|
||
---
|
||
|
||
### 시나리오 4: 서버 재시작 후 자동 상태 복구
|
||
|
||
**서버 재시작 전**:
|
||
```json
|
||
{
|
||
"statusCd": "IN_PROGRESS",
|
||
"step1Status": "IN_PROGRESS"
|
||
}
|
||
```
|
||
|
||
**서버 재시작 후 API 호출**:
|
||
```javascript
|
||
// 주기적 폴링 또는 수동 호출
|
||
await axios.post(`/api/train/status/${uuid}`);
|
||
```
|
||
|
||
**케이스 A) 학습 완료된 경우**:
|
||
```json
|
||
{
|
||
"statusCd": "COMPLETED",
|
||
"step1Status": "COMPLETED",
|
||
"step1EndDttm": "2026-04-06 15:00:00",
|
||
"step1MetricSaveYn": true
|
||
}
|
||
```
|
||
- ✅ 완료 - 학습 완료
|
||
- 버튼: [테스트 실행] [결과 보기]
|
||
|
||
**케이스 B) 산출물 부족한 경우**:
|
||
```json
|
||
{
|
||
"statusCd": "STOPPED",
|
||
"step1Status": "STOPPED",
|
||
"lastError": "SERVER_RESTART_CONTAINER_MISSING_OUTPUT_INCOMPLETE: val.csv-lines-mismatch"
|
||
}
|
||
```
|
||
- ⚠️ 중단됨 - 산출물 부족으로 중단됨
|
||
- 버튼: [재실행] [이어하기]
|
||
|
||
**케이스 C) 여전히 실행 중인 경우**:
|
||
```json
|
||
{
|
||
"statusCd": "IN_PROGRESS",
|
||
"step1Status": "IN_PROGRESS"
|
||
}
|
||
```
|
||
- 🔄 진행중 - 학습 진행 중...
|
||
- 버튼: [학습 취소]
|
||
|
||
---
|
||
|
||
## 📊 8. 에러 메시지 처리
|
||
|
||
### 8.1 `last_error` 필드 해석
|
||
|
||
| 에러 메시지 | 의미 | 프론트 표시 | 권장 액션 |
|
||
|------------|------|-----------|----------|
|
||
| `SERVER_RESTART_CONTAINER_MISSING_OUTPUT_INCOMPLETE` | 서버 재시작 후 컨테이너 없음 + 산출물 부족 | "서버 재시작으로 인한 중단 - 산출물 확인 필요" | [재실행] |
|
||
| `val.csv-lines-mismatch` | val.csv 라인 수 부족 | "검증 데이터 부족 - 학습이 완료되지 않음" | [재실행] [이어하기] |
|
||
| `val.csv-missing` | val.csv 파일 없음 | "검증 파일 없음 - 학습 실패" | [재실행] |
|
||
| `total-epoch-missing` | paramsJson에 total_epoch 없음 | "설정 오류 - 에폭 정보 없음" | [재실행] |
|
||
| `output-dir-missing` | 산출물 디렉토리 없음 | "산출물 디렉토리 없음 - 학습 실패" | [재실행] |
|
||
|
||
### 8.2 에러 표시 컴포넌트
|
||
|
||
```javascript
|
||
function ErrorMessage({ lastError }) {
|
||
if (!lastError) return null;
|
||
|
||
const errorMessages = {
|
||
'SERVER_RESTART_CONTAINER_MISSING_OUTPUT_INCOMPLETE': {
|
||
icon: '⚠️',
|
||
title: '서버 재시작으로 인한 중단',
|
||
message: '서버가 재시작되면서 학습이 중단되었습니다. 산출물을 확인하여 학습 상태를 복구합니다.',
|
||
severity: 'warning'
|
||
},
|
||
'val.csv-lines-mismatch': {
|
||
icon: '📊',
|
||
title: '검증 데이터 부족',
|
||
message: '검증 데이터 라인 수가 예상보다 적습니다. 학습이 완료되지 않았을 가능성이 있습니다.',
|
||
severity: 'warning'
|
||
},
|
||
'val.csv-missing': {
|
||
icon: '❌',
|
||
title: '검증 파일 없음',
|
||
message: 'val.csv 파일을 찾을 수 없습니다. 학습이 실패했을 가능성이 높습니다.',
|
||
severity: 'error'
|
||
}
|
||
};
|
||
|
||
// 에러 메시지 파싱
|
||
const errorKey = Object.keys(errorMessages).find(key => lastError.includes(key));
|
||
const errorInfo = errorMessages[errorKey] || {
|
||
icon: '⚠️',
|
||
title: '오류 발생',
|
||
message: lastError,
|
||
severity: 'error'
|
||
};
|
||
|
||
return (
|
||
<div className={`error-message severity-${errorInfo.severity}`}>
|
||
<div className="error-header">
|
||
<span className="error-icon">{errorInfo.icon}</span>
|
||
<span className="error-title">{errorInfo.title}</span>
|
||
</div>
|
||
<p className="error-description">{errorInfo.message}</p>
|
||
</div>
|
||
);
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 🔍 9. 상태 일관성 체크리스트
|
||
|
||
### 프론트엔드 개발 시 확인사항
|
||
|
||
#### ✅ 상태 표시
|
||
- [ ] `statusCd`를 UI에 정확히 매핑 (READY, IN_PROGRESS, COMPLETED, STOPPED, ERROR)
|
||
- [ ] `step1Status`, `step2Status` 개별 표시
|
||
- [ ] 한글 상태명 표시 (statusName, step1StatusName, step2StatusName 활용)
|
||
- [ ] 상태별 적절한 색상/아이콘 사용
|
||
|
||
#### ✅ 버튼 활성화/비활성화
|
||
- [ ] `statusCd`에 따른 버튼 조건 확인
|
||
- [ ] `step1Status`, `step2Status` 조합 고려
|
||
- [ ] 중복 실행 방지 (disabled 속성)
|
||
|
||
#### ✅ 시간 정보 표시
|
||
- [ ] `step1StrtDttm`, `step1EndDttm` 표시
|
||
- [ ] `step2StrtDttm`, `step2EndDttm` 표시
|
||
- [ ] `step1Duration`, `step2Duration` 계산 표시
|
||
|
||
#### ✅ 에러 처리
|
||
- [ ] `lastError` 메시지 파싱 및 표시
|
||
- [ ] 사용자 친화적 에러 메시지 변환
|
||
- [ ] 에러 발생 시 복구 방법 안내
|
||
|
||
#### ✅ 주기적 업데이트
|
||
- [ ] 진행 중인 모델 폴링 (10초 간격 권장)
|
||
- [ ] `POST /api/train/status/{uuid}` 주기 호출
|
||
- [ ] 목록 자동 갱신
|
||
|
||
---
|
||
|
||
## 💡 10. 베스트 프랙티스
|
||
|
||
### 10.1 상태 동기화
|
||
|
||
```javascript
|
||
// ❌ 나쁜 예: 프론트에서 임의로 상태 변경
|
||
function handleCancel() {
|
||
model.statusCd = 'STOPPED'; // 직접 변경 X
|
||
updateUI();
|
||
}
|
||
|
||
// ✅ 좋은 예: API 호출 후 서버 응답 기준으로 업데이트
|
||
async function handleCancel() {
|
||
await axios.post(`/api/train/cancel/${uuid}`);
|
||
const updated = await axios.get(`/api/models/list`);
|
||
setModels(updated.data.content);
|
||
}
|
||
```
|
||
|
||
### 10.2 낙관적 UI 업데이트
|
||
|
||
```javascript
|
||
// ✅ 사용자 경험 향상: 즉시 UI 업데이트 + 백그라운드 검증
|
||
async function handleRun() {
|
||
// 1. 즉시 UI 업데이트 (낙관적)
|
||
setModel(prev => ({ ...prev, statusCd: 'IN_PROGRESS' }));
|
||
|
||
try {
|
||
// 2. API 호출
|
||
await axios.post(`/api/train/run/${uuid}`);
|
||
|
||
// 3. 실제 상태 확인
|
||
setTimeout(() => checkTrainStatus(uuid), 2000);
|
||
} catch (error) {
|
||
// 4. 실패 시 롤백
|
||
setModel(prev => ({ ...prev, statusCd: 'READY' }));
|
||
alert('실행 실패: ' + error.message);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 10.3 상태별 UI 일관성
|
||
|
||
```css
|
||
/* 상태별 일관된 색상 스타일 */
|
||
.status-badge.ready { background: #e3f2fd; color: #1976d2; }
|
||
.status-badge.in-progress { background: #e8f5e9; color: #388e3c; }
|
||
.status-badge.completed { background: #f1f8e9; color: #689f38; }
|
||
.status-badge.stopped { background: #fff3e0; color: #f57c00; }
|
||
.status-badge.error { background: #ffebee; color: #d32f2f; }
|
||
|
||
/* 버튼 스타일 */
|
||
.btn-primary { background: #1976d2; color: white; }
|
||
.btn-success { background: #388e3c; color: white; }
|
||
.btn-warning { background: #f57c00; color: white; }
|
||
.btn-danger { background: #d32f2f; color: white; }
|
||
.btn-info { background: #0288d1; color: white; }
|
||
```
|
||
|
||
---
|
||
|
||
## 📝 요약
|
||
|
||
### 상태 확인 방법
|
||
1. **API 호출**: `POST /api/train/status/{uuid}`
|
||
2. **응답 확인**: `statusCd`, `step1Status`, `step2Status`
|
||
3. **UI 반영**: 상태별 배지/아이콘 표시
|
||
|
||
### 상태 변경 방법
|
||
1. **적절한 제어 API 호출**:
|
||
- 실행: `POST /api/train/run/{uuid}`
|
||
- 취소: `POST /api/train/cancel/{uuid}`
|
||
- 재실행: `POST /api/train/restart/{uuid}`
|
||
- 이어하기: `POST /api/train/resume/{uuid}`
|
||
|
||
2. **버튼 조건부 표시**:
|
||
- `statusCd`, `step1Status`, `step2Status` 조합 확인
|
||
|
||
3. **주기적 폴링**:
|
||
- 진행 중(`IN_PROGRESS`) 상태일 때만 10초 간격 폴링
|
||
|
||
---
|
||
|
||
|
||
|