📝 ✨ thêm ứng dụng giải đố Water Sort Puzzle với AI

- Triển khai toàn bộ ứng dụng giải đố Water Sort Puzzle bằng Gradio.
- Tích hợp mô hình AI (WaterSortNet) để đưa ra gợi ý nước đi tối ưu.
- Cấu trúc lại dự án với các module cấu hình, logging và tiện ích chung mới.
- Cập nhật README chi tiết về cài đặt, sử dụng và tính năng của ứng dụng.
- Bổ sung file .env.example và .gitignore để quản lý môi trường dự án.

.env.example

@@ -0,0 +1,6 @@
+# Environment variables
+DEVICE=auto
+DEBUG=False
+SHARE=False
+SERVER_PORT=7860
+MODEL_PRECISION=fp32

.gitignore

@@ -0,0 +1 @@
+.env

README.md

@@ -1,12 +1,60 @@
----
-title: WaterSortSpace
-emoji: 🚀
-colorFrom: yellow
-colorTo: green
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Water Sort Puzzle Solver - Gradio App
+
+Ứng dụng giải Water Sort Puzzle với AI sử dụng Gradio.
+
+## Yêu cầu
+
+- Python 3.8+
+- PyTorch (GPU hoặc CPU)
+- Gradio 4.0+
+
+## Cài đặt
+
+1. Clone repo hoặc tải file
+2. Cài đặt dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Tạo folder `models` và upload các file `.pth`:
+```bash
+mkdir models
+# Copy file .pth vào folder này
+```
+
+4. Chạy ứng dụng:
+```bash
+python app.py
+```
+
+5. Mở browser: http://localhost:7860
+
+## Cách sử dụng
+
+1. **Chọn Model**: Chọn model từ dropdown và click "Tải Model"
+2. **Bắt đầu**: Click "Bắt đầu" để tạo game mới
+3. **Di chuyển**: Click hai chai liên tiếp (chai nguồn → chai đích)
+4. **Gợi ý**: Click "Gợi ý" để AI gợi ý nước đi tiếp theo
+5. **Reset**: Click "Reset" để chơi lại
+
+## Tính năng
+
+- 🎮 Giao diện trực quan với Gradio
+- 🤖 AI gợi ý nước đi tối ưu
+- 📊 Hiển thị thống kê game (số bước, model, device)
+- 💾 Hỗ trợ nhiều model khác nhau
+- 🚀 Hỗ trợ GPU/CPU
+
+## Model cần thiết
+
+Đặt các file model trong folder `models/`:
+- `watersort_imitation.pth` (từ Imitation Learning)
+- `watersort_rl_model.pth` (từ Reinforcement Learning)
+- Hoặc bất kỳ model nào khác
+
+## Troubleshooting
+
+### Model không load được
+- Kiểm tra đường dẫn file model
+- Kiểm tra định dạng file (phải là .pth)
+- Ki

app.py

@@ -0,0 +1,571 @@
+import gradio as gr
+import numpy as np
+import torch
+import torch.nn as nn
+import os
+import json
+from pathlib import Path
+import random
+from typing import List, Tuple, Dict, Optional
+from datetime import datetime
+import threading
+import time
+
+# =============================================================================
+# 1. WATER SORT ENVIRONMENT
+# =============================================================================
+
+class WaterSortEnv:
+    def __init__(self, num_colors=6, bottle_height=4, num_bottles=8):
+        self.num_colors = num_colors
+        self.bottle_height = bottle_height
+        self.num_bottles = num_bottles
+        self.bottles = np.zeros((num_bottles, bottle_height), dtype=int)
+        self.move_history = []
+        self.game_started = False
+        self.game_finished = False
+    
+    def reset(self) -> np.ndarray:
+        """Reset game to solvable initial state"""
+        colors = list(range(1, self.num_colors + 1)) * self.bottle_height
+        random.shuffle(colors)
+        
+        self.bottles = np.zeros((self.num_bottles, self.bottle_height), dtype=int)
+        color_idx = 0
+        
+        for i in range(self.num_bottles - 2):
+            for j in range(self.bottle_height):
+                if color_idx < len(colors):
+                    self.bottles[i, self.bottle_height - 1 - j] = colors[color_idx]
+                    color_idx += 1
+        
+        self.move_history = []
+        self.game_started = True
+        self.game_finished = False
+        return self.get_state()
+    
+    def get_state(self) -> np.ndarray:
+        return self.bottles.copy()
+    
+    def get_valid_moves(self) -> List[Tuple[int, int]]:
+        """Get all valid moves"""
+        valid_moves = []
+        for from_idx in range(self.num_bottles):
+            for to_idx in range(self.num_bottles):
+                if from_idx != to_idx and self._is_valid_move(from_idx, to_idx):
+                    valid_moves.append((from_idx, to_idx))
+        return valid_moves
+    
+    def _is_valid_move(self, from_idx: int, to_idx: int) -> bool:
+        """Check if move is valid"""
+        from_bottle = self.bottles[from_idx]
+        to_bottle = self.bottles[to_idx]
+        
+        if np.sum(from_bottle > 0) == 0:
+            return False
+        if np.sum(to_bottle > 0) == self.bottle_height:
+            return False
+        
+        source_top_idx = np.where(from_bottle > 0)[0]
+        if len(source_top_idx) == 0:
+            return False
+        source_top_color = from_bottle[source_top_idx[0]]
+        
+        dest_top_idx = np.where(to_bottle > 0)[0]
+        if len(dest_top_idx) == 0:
+            return True
+        dest_top_color = to_bottle[dest_top_idx[0]]
+        
+        return source_top_color == dest_top_color
+    
+    def step(self, action: Tuple[int, int]):
+        """Execute move"""
+        from_idx, to_idx = action
+        
+        if not self._is_valid_move(from_idx, to_idx):
+            return self.get_state(), -1, False
+        
+        self._pour_liquid(from_idx, to_idx)
+        self.move_history.append((from_idx, to_idx))
+        done = self.is_solved()
+        
+        if done:
+            self.game_finished = True
+        
+        reward = 10.0 if done else 0.1
+        return self.get_state(), reward, done
+    
+    def _pour_liquid(self, from_idx: int, to_idx: int):
+        """Pour liquid from one bottle to another"""
+        from_bottle = self.bottles[from_idx]
+        to_bottle = self.bottles[to_idx]
+        
+        source_non_empty = np.where(from_bottle > 0)[0]
+        if len(source_non_empty) == 0:
+            return
+        
+        source_top_idx = source_non_empty[0]
+        source_color = from_bottle[source_top_idx]
+        
+        pour_amount = 1
+        for i in range(source_top_idx + 1, len(from_bottle)):
+            if from_bottle[i] == source_color:
+                pour_amount += 1
+            else:
+                break
+        
+        dest_empty = np.where(to_bottle == 0)[0]
+        if len(dest_empty) == 0:
+            return
+        
+        available_space = len(dest_empty)
+        actual_pour = min(pour_amount, available_space)
+        
+        for i in range(actual_pour):
+            from_pos = source_top_idx + i
+            to_pos = dest_empty[-(i+1)]
+            self.bottles[to_idx, to_pos] = source_color
+            self.bottles[from_idx, from_pos] = 0
+    
+    def is_solved(self) -> bool:
+        """Check if puzzle is solved"""
+        for bottle in self.bottles:
+            unique_colors = np.unique(bottle[bottle > 0])
+            if len(unique_colors) > 1:
+                return False
+            if len(unique_colors) == 1 and np.sum(bottle > 0) != self.bottle_height and np.sum(bottle > 0) != 0:
+                return False
+        return True
+
+# =============================================================================
+# 2. NEURAL NETWORK ARCHITECTURE
+# =============================================================================
+
+class WaterSortNet(nn.Module):
+    def __init__(self, num_bottles=8, bottle_height=4, num_colors=6):
+        super(WaterSortNet, self).__init__()
+        self.num_bottles = num_bottles
+        self.bottle_height = bottle_height
+        self.num_colors = num_colors
+        
+        self.conv1 = nn.Conv2d(num_colors, 128, kernel_size=3, padding=1)
+        self.conv2 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
+        self.conv3 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
+        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
+        
+        self.bn1 = nn.BatchNorm2d(128)
+        self.bn2 = nn.BatchNorm2d(128)
+        self.bn3 = nn.BatchNorm2d(128)
+        self.bn4 = nn.BatchNorm2d(128)
+        
+        self.policy_conv = nn.Conv2d(128, 64, kernel_size=3, padding=1)
+        self.policy_fc1 = nn.Linear(64 * num_bottles * bottle_height, 512)
+        self.policy_fc2 = nn.Linear(512, num_bottles * num_bottles)
+        self.policy_bn = nn.BatchNorm1d(512)
+        
+        self.value_conv = nn.Conv2d(128, 64, kernel_size=3, padding=1)
+        self.value_fc1 = nn.Linear(64 * num_bottles * bottle_height, 512)
+        self.value_fc2 = nn.Linear(512, 256)
+        self.value_fc3 = nn.Linear(256, 1)
+        self.value_bn1 = nn.BatchNorm1d(512)
+        self.value_bn2 = nn.BatchNorm1d(256)
+        
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.3)
+    
+    def forward(self, x):
+        batch_size = x.size(0)
+        
+        x = self.relu(self.bn1(self.conv1(x)))
+        x = self.relu(self.bn2(self.conv2(x)))
+        x = self.relu(self.bn3(self.conv3(x)))
+        x = self.relu(self.bn4(self.conv4(x)))
+        
+        policy = self.relu(self.policy_conv(x))
+        policy = policy.view(batch_size, -1)
+        policy = self.dropout(self.relu(self.policy_bn(self.policy_fc1(policy))))
+        policy = self.policy_fc2(policy)
+        
+        value = self.relu(self.value_conv(x))
+        value = value.view(batch_size, -1)
+        value = self.dropout(self.relu(self.value_bn1(self.value_fc1(value))))
+        value = self.dropout(self.relu(self.value_bn2(self.value_fc2(value))))
+        value = torch.tanh(self.value_fc3(value))
+        
+        return policy, value
+
+# =============================================================================
+# 3. DATA PROCESSOR
+# =============================================================================
+
+class DataProcessor:
+    def __init__(self, num_bottles=8, bottle_height=4, num_colors=6):
+        self.num_bottles = num_bottles
+        self.bottle_height = bottle_height
+        self.num_colors = num_colors
+    
+    def state_to_tensor(self, state):
+        """Chuyển state thành one-hot encoded tensor"""
+        one_hot = np.zeros((self.num_colors, self.num_bottles, self.bottle_height), dtype=np.float32)
+        
+        for bottle_idx in range(self.num_bottles):
+            for height_idx in range(self.bottle_height):
+                color = int(state[bottle_idx, height_idx])
+                if color > 0:
+                    one_hot[color - 1, bottle_idx, height_idx] = 1.0
+        
+        return torch.from_numpy(one_hot)
+
+# =============================================================================
+# 4. GAME STATE MANAGER
+# =============================================================================
+
+class GameStateManager:
+    def __init__(self):
+        self.env = WaterSortEnv()
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.processor = DataProcessor()
+        self.current_model_name = None
+        self.ai_running = False
+        self.selected_bottles = None
+        self.game_stats = {
+            'moves_count': 0,
+            'start_time': None,
+            'ai_suggested_move': None,
+            'valid_moves': []
+        }
+    
+    def load_model(self, model_path: str) -> bool:
+        """Load model từ file"""
+        try:
+            self.model = WaterSortNet(num_bottles=8, bottle_height=4, num_colors=6).to(self.device)
+            checkpoint = torch.load(model_path, map_location=self.device)
+            
+            if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                self.model.load_state_dict(checkpoint['model_state_dict'])
+            else:
+                self.model.load_state_dict(checkpoint)
+            
+            self.model.eval()
+            self.current_model_name = Path(model_path).stem
+            return True
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            return False
+    
+    def start_game(self):
+        """Bắt đầu game mới"""
+        self.env.reset()
+        self.game_stats = {
+            'moves_count': 0,
+            'start_time': datetime.now(),
+            'ai_suggested_move': None,
+            'valid_moves': self.env.get_valid_moves()
+        }
+        self.selected_bottles = None
+        return self.env.get_state()
+    
+    def reset_game(self):
+        """Reset game"""
+        self.env.game_finished = False
+        return self.start_game()
+    
+    def get_next_move_suggestion(self) -> Optional[Tuple[int, int]]:
+        """Lấy gợi ý từ AI"""
+        if self.model is None:
+            return None
+        
+        try:
+            state = self.env.get_state()
+            valid_moves = self.env.get_valid_moves()
+            
+            if not valid_moves:
+                return None
+            
+            state_tensor = self.processor.state_to_tensor(state).unsqueeze(0).to(self.device)
+            
+            with torch.no_grad():
+                policy, _ = self.model(state_tensor)
+            
+            policy_probs = torch.softmax(policy, dim=1).cpu().numpy()[0]
+            
+            best_move = None
+            best_score = -float('inf')
+            
+            for move in valid_moves:
+                from_idx, to_idx = move
+                move_index = from_idx * 8 + to_idx
+                score = policy_probs[move_index]
+                
+                if score > best_score:
+                    best_score = score
+                    best_move = move
+            
+            self.game_stats['ai_suggested_move'] = best_move
+            return best_move
+        except Exception as e:
+            print(f"Error getting suggestion: {e}")
+            return None
+    
+    def make_move(self, from_bottle: int, to_bottle: int) -> Tuple[bool, str]:
+        """Thực hiện di chuyển"""
+        state, reward, done = self.env.step((from_bottle, to_bottle))
+        
+        if reward < 0:
+            return False, "Nước không thể đổ vào chai này!"
+        
+        self.game_stats['moves_count'] += 1
+        self.game_stats['valid_moves'] = self.env.get_valid_moves()
+        self.selected_bottles = None
+        
+        if done:
+            return True, f"Chúc mừng! Bạn đã giải xong trong {self.game_stats['moves_count']} bước!"
+        
+        return True, f"Bước thành công! Tổng bước: {self.game_stats['moves_count']}"
+    
+    def select_bottle(self, bottle_idx: int) -> str:
+        """Chọn chai"""
+        if self.selected_bottles is None:
+            self.selected_bottles = bottle_idx
+            return f"Đã chọn chai {bottle_idx}. Chọn chai đích."
+        else:
+            from_bottle = self.selected_bottles
+            to_bottle = bottle_idx
+            success, message = self.make_move(from_bottle, to_bottle)
+            return message
+
+# =============================================================================
+# 5. VISUALIZATION
+# =============================================================================
+
+def draw_game_board(state: np.ndarray, selected_bottle: Optional[int] = None) -> str:
+    """Vẽ bảng game dưới dạng HTML"""
+    colors_map = {
+        0: '#ffffff',
+        1: '#FF6B6B',
+        2: '#4ECDC4',
+        3: '#45B7D1',
+        4: '#FFA07A',
+        5: '#98D8C8',
+        6: '#F7DC6F'
+    }
+    
+    html = '<div style="display: flex; gap: 20px; flex-wrap: wrap; justify-content: center; padding: 20px;">'
+    
+    num_bottles = state.shape[0]
+    bottle_height = state.shape[1]
+    
+    for bottle_idx in range(num_bottles):
+        bottle = state[bottle_idx]
+        is_selected = bottle_idx == selected_bottle
+        border_style = 'border: 3px solid #FFD700;' if is_selected else 'border: 2px solid #333;'
+        
+        html += f'<div style="text-align: center; margin: 10px;">'
+        html += f'<div style="width: 60px; height: 150px; {border_style} background: #f0f0f0; margin-bottom: 10px; display: flex; flex-direction: column-reverse; overflow: hidden;">'
+        
+        for height_idx in range(bottle_height):
+            color_val = int(bottle[height_idx])
+            color = colors_map.get(color_val, '#ffffff')
+            html += f'<div style="width: 100%; height: 30px; background: {color}; border-bottom: 1px solid #999;"></div>'
+        
+        html += '</div>'
+        html += f'<p style="margin: 5px 0; font-weight: bold;">Chai {bottle_idx}</p>'
+        html += '</div>'
+    
+    html += '</div>'
+    return html
+
+def get_game_stats_html(game_manager: GameStateManager) -> str:
+    """Tạo HTML hiển thị thống kê game"""
+    stats = game_manager.game_stats
+    model_info = game_manager.current_model_name if game_manager.current_model_name else "Chưa tải"
+    
+    html = f"""
+    <div style="background: #f5f5f5; padding: 15px; border-radius: 8px; margin: 10px 0;">
+        <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px;">
+            <div>
+                <p style="margin: 0; font-size: 12px; color: #666;">📊 Số bước</p>
+                <p style="margin: 5px 0; font-size: 24px; font-weight: bold;">{stats['moves_count']}</p>
+            </div>
+            <div>
+                <p style="margin: 0; font-size: 12px; color: #666;">🤖 Model</p>
+                <p style="margin: 5px 0; font-size: 14px; font-weight: bold;">{model_info}</p>
+            </div>
+            <div>
+                <p style="margin: 0; font-size: 12px; color: #666;">💾 Thiết bị</p>
+                <p style="margin: 5px 0; font-size: 14px; font-weight: bold;">{'GPU' if torch.cuda.is_available() else 'CPU'}</p>
+            </div>
+        </div>
+        <p style="margin: 10px 0; font-size: 12px; color: #999;">
+            Nước hợp lệ: {len(stats['valid_moves'])} nước
+        </p>
+    </div>
+    """
+    return html
+
+# =============================================================================
+# 6. MAIN GRADIO APP
+# =============================================================================
+
+def get_available_models() -> List[str]:
+    """Lấy danh sách model từ folder models"""
+    models_dir = Path("models")
+    models_dir.mkdir(exist_ok=True)
+    
+    model_files = list(models_dir.glob("*.pth"))
+    return [f.name for f in sorted(model_files)]
+
+# Initialize global game manager
+game_manager = GameStateManager()
+
+def load_model_ui(selected_model: str) -> Tuple[str, str]:
+    """Load model từ UI"""
+    if not selected_model:
+        return "❌ Vui lòng chọn model", ""
+    
+    model_path = Path("models") / selected_model
+    if game_manager.load_model(str(model_path)):
+        return f"✅ Tải model thành công: {selected_model}", draw_game_board(np.zeros((8, 4)))
+    else:
+        return f"❌ Lỗi khi tải model: {selected_model}", ""
+
+def start_game_ui() -> Tuple[str, str, str]:
+    """Bắt đầu game mới"""
+    state = game_manager.start_game()
+    board = draw_game_board(state)
+    stats = get_game_stats_html(game_manager)
+    return stats, board, "✅ Bắt đầu game mới!"
+
+def reset_game_ui() -> Tuple[str, str, str]:
+    """Reset game"""
+    state = game_manager.reset_game()
+    board = draw_game_board(state)
+    stats = get_game_stats_html(game_manager)
+    return stats, board, "🔄 Game đã được reset!"
+
+def suggest_move_ui() -> Tuple[str, str]:
+    """Gợi ý di chuyển từ AI"""
+    if game_manager.model is None:
+        return "", "❌ Vui lòng tải model trước!"
+    
+    if game_manager.env.game_finished:
+        return "", "🎉 Game đã kết thúc!"
+    
+    move = game_manager.get_next_move_suggestion()
+    if move:
+        from_bottle, to_bottle = move
+        message = f"💡 Gợi ý: Đổ từ chai {from_bottle} sang chai {to_bottle}"
+        return message, message
+    else:
+        return "", "❌ Không thể tìm được nước gợi ý"
+
+def bottle_click_ui(bottle_idx: int) -> Tuple[str, str, str]:
+    """Xử lý click bottle"""
+    if not game_manager.env.game_started:
+        return "", draw_game_board(game_manager.env.get_state()), "❌ Vui lòng bắt đầu game!"
+    
+    if game_manager.env.game_finished:
+        return "", draw_game_board(game_manager.env.get_state()), "🎉 Game đã kết thúc!"
+    
+    if game_manager.selected_bottles is None:
+        game_manager.selected_bottles = bottle_idx
+        state = game_manager.env.get_state()
+        board = draw_game_board(state, bottle_idx)
+        stats = get_game_stats_html(game_manager)
+        return stats, board, f"✓ Chọn chai {bottle_idx}. Chọn chai đích."
+    else:
+        from_bottle = game_manager.selected_bottles
+        to_bottle = bottle_idx
+        success, message = game_manager.make_move(from_bottle, to_bottle)
+        
+        state = game_manager.env.get_state()
+        board = draw_game_board(state)
+        stats = get_game_stats_html(game_manager)
+        
+        return stats, board, message
+
+def create_bottle_buttons():
+    """Tạo buttons cho các chai"""
+    buttons = []
+    for i in range(8):
+        buttons.append(
+            gr.Button(f"Chai {i}", size="lg", scale=1)
+        )
+    return buttons
+
+# Create Gradio Interface
+with gr.Blocks(title="Water Sort Puzzle", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧪 Water Sort Puzzle Solver")
+    gr.Markdown("Giải Water Sort Puzzle với sự trợ giúp của AI!")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ Cấu hình")
+            
+            model_dropdown = gr.Dropdown(
+                label="Chọn Model",
+                choices=get_available_models(),
+                interactive=True
+            )
+            
+            load_model_btn = gr.Button("📥 Tải Model", variant="primary", size="lg")
+            model_status = gr.Textbox(label="Trạng thái", interactive=False)
+            
+            gr.Markdown("### 🎮 Điều khiển")
+            start_btn = gr.Button("🎮 Bắt đầu", variant="primary", size="lg")
+            reset_btn = gr.Button("🔄 Reset", size="lg")
+            suggest_btn = gr.Button("💡 Gợi ý", size="lg")
+            
+            gr.Markdown("### 📊 Thống kê")
+            game_stats = gr.HTML()
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 🎯 Bảng trò chơi")
+            game_board = gr.HTML()
+            
+            gr.Markdown("### Chọn chai để di chuyển")
+            with gr.Row():
+                bottle_buttons = create_bottle_buttons()
+            
+            message_display = gr.Textbox(
+                label="Thông báo",
+                interactive=False,
+                lines=2
+            )
+            
+            suggestion_display = gr.Textbox(
+                label="Gợi ý từ AI",
+                interactive=False
+            )
+    
+    # Event handlers
+    load_model_btn.click(
+        fn=load_model_ui,
+        inputs=[model_dropdown],
+        outputs=[model_status, game_board]
+    )
+    
+    start_btn.click(
+        fn=start_game_ui,
+        outputs=[game_stats, game_board, message_display]
+    )
+    
+    reset_btn.click(
+        fn=reset_game_ui,
+        outputs=[game_stats, game_board, message_display]
+    )
+    
+    suggest_btn.click(
+        fn=suggest_move_ui,
+        outputs=[suggestion_display, message_display]
+    )
+    
+    for i, btn in enumerate(bottle_buttons):
+        btn.click(
+            fn=lambda idx=i: bottle_click_ui(idx),
+            outputs=[game_stats, game_board, message_display]
+        )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

config.py

@@ -0,0 +1,54 @@
+# config.py
+import os
+from pathlib import Path
+from typing import Dict
+
+# Đường dẫn
+PROJECT_ROOT = Path(__file__).parent
+MODELS_DIR = PROJECT_ROOT / "models"
+
+# Game configuration
+GAME_CONFIG = {
+    'num_colors': 6,
+    'bottle_height': 4,
+    'num_bottles': 8,
+    'max_moves': 200
+}
+
+# UI configuration
+UI_CONFIG = {
+    'theme': 'soft',
+    'server_name': '0.0.0.0',
+    'server_port': 7860,
+    'share': False,
+    'debug': False
+}
+
+# Model configuration
+MODEL_CONFIG = {
+    'device': 'auto',  # 'auto', 'cuda', 'cpu'
+    'precision': 'fp32',  # 'fp32' hoặc 'fp16'
+}
+
+# Color mapping for visualization
+COLORS_MAP = {
+    0: '#ffffff',      # White (empty)
+    1: '#FF6B6B',      # Red
+    2: '#4ECDC4',      # Teal
+    3: '#45B7D1',      # Blue
+    4: '#FFA07A',      # Light Salmon
+    5: '#98D8C8',      # Mint
+    6: '#F7DC6F'       # Yellow
+}
+
+# Ensure models directory exists
+MODELS_DIR.mkdir(exist_ok=True)
+
+# Create config dict
+CONFIG = {
+    'game': GAME_CONFIG,
+    'ui': UI_CONFIG,
+    'model': MODEL_CONFIG,
+    'colors': COLORS_MAP,
+    'models_dir': str(MODELS_DIR)
+}

logger.py

@@ -0,0 +1,38 @@
+# logger.py
+import logging
+import sys
+from pathlib import Path
+from datetime import datetime
+
+def setup_logger(name: str, log_file: str = None) -> logging.Logger:
+    """Thiết lập logger"""
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_format = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    console_handler.setFormatter(console_format)
+    logger.addHandler(console_handler)
+    
+    # File handler (optional)
+    if log_file:
+        Path(log_file).parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)
+        file_format = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        file_handler.setFormatter(file_format)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+# Initialize main logger
+logger = setup_logger(
+    'water_sort_app',
+    log_file=f'logs/app_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
+)

utils.py

@@ -0,0 +1,89 @@
+# utils.py
+import numpy as np
+from pathlib import Path
+from typing import List, Tuple, Optional
+import torch
+import config
+
+def get_available_models() -> List[str]:
+    """Lấy danh sách tất cả model trong folder models"""
+    models_dir = Path(config.CONFIG['models_dir'])
+    model_files = list(models_dir.glob("*.pth"))
+    return sorted([f.name for f in model_files])
+
+def validate_model_file(model_path: str) -> bool:
+    """Kiểm tra xem file model có hợp lệ không"""
+    path = Path(model_path)
+    
+    if not path.exists():
+        return False
+    
+    if path.suffix != '.pth':
+        return False
+    
+    if path.stat().st_size < 1000:  # File quá nhỏ
+        return False
+    
+    return True
+
+def format_time(seconds: float) -> str:
+    """Format thời gian từ giây sang HH:MM:SS"""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    
+    if hours > 0:
+        return f"{hours}h {minutes}m {secs}s"
+    elif minutes > 0:
+        return f"{minutes}m {secs}s"
+    else:
+        return f"{secs}s"
+
+def get_color_for_value(color_val: int) -> str:
+    """Lấy màu hex từ giá trị color"""
+    return config.COLORS_MAP.get(color_val, '#ffffff')
+
+def create_bottle_html(bottle_state: np.ndarray, bottle_idx: int, 
+                       selected: bool = False) -> str:
+    """Tạo HTML cho một chai"""
+    border_color = '#FFD700' if selected else '#333'
+    border_width = '3' if selected else '2'
+    
+    html = f'<div style="text-align: center; margin: 10px;">'
+    html += f'<div style="width: 60px; height: 150px; border: {border_width}px solid {border_color}; '
+    html += f'background: #f0f0f0; margin-bottom: 10px; display: flex; flex-direction: column-reverse; overflow: hidden;">'
+    
+    for height_idx in range(len(bottle_state)):
+        color_val = int(bottle_state[height_idx])
+        color = get_color_for_value(color_val)
+        html += f'<div style="width: 100%; height: 30px; background: {color}; border-bottom: 1px solid #999;"></div>'
+    
+    html += '</div>'
+    html += f'<p style="margin: 5px 0; font-weight: bold;">Chai {bottle_idx}</p>'
+    html += '</div>'
+    
+    return html
+
+def get_device() -> torch.device:
+    """Lấy device (GPU hoặc CPU)"""
+    device_config = config.MODEL_CONFIG['device']
+    
+    if device_config == 'auto':
+        return torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    elif device_config == 'cuda':
+        if torch.cuda.is_available():
+            return torch.device('cuda')
+        else:
+            print("Warning: CUDA not available, falling back to CPU")
+            return torch.device('cpu')
+    else:
+        return torch.device('cpu')
+
+def print_device_info():
+    """In thông tin về device"""
+    device = get_device()
+    print(f"Device: {device}")
+    
+    if device.type == 'cuda':
+        print(f"GPU Name: {torch.cuda.get_device_name(0)}")
+        print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")