update_ver2

app.py

@@ -0,0 +1,44 @@
+"""
+Ứng dụng web phân loại ảnh Chó và Mèo sử dụng Streamlit
+--------------------------------------------------
+Ứng dụng này cung cấp giao diện web thân thiện để phân loại ảnh chó và mèo
+sử dụng mô hình ResNet18 đã được huấn luyện. Người dùng có thể tải ảnh lên,
+và ứng dụng sẽ đưa ra dự đoán kèm theo độ tin cậy của kết quả.
+
+Chức năng chính:
+- Tải lên ảnh từ máy của người dùng
+- Hiển thị ảnh đã tải lên
+- Sử dụng mô hình ResNet18 để phân loại ảnh
+- Hiển thị kết quả phân loại (Chó/Mèo) và độ tin cậy của dự đoán
+"""
+import streamlit as st
+from predict_resnet18 import predict_image
+import tempfile
+from PIL import Image
+
+st.set_page_config(page_title="Phân loại Chó/Mèo", layout="centered")
+st.title("🐾 Ứng dụng phân loại ảnh Chó và Mèo")
+st.write("Tải ảnh lên để xem dự đoán mô hình phân loại là **Chó** hay **Mèo** 🐶🐱")
+
+# Upload ảnh
+uploaded_file = st.file_uploader("📷 Tải ảnh lên", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    try:
+        # Hiển thị ảnh
+        image = Image.open(uploaded_file).convert("RGB")
+        st.image(image, caption="Ảnh đã tải lên", use_container_width=True)
+
+        # Lưu tạm ảnh để truyền đường dẫn vào hàm predict_image
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp_file:
+            image.save(tmp_file.name)
+            tmp_path = tmp_file.name
+
+        # Dự đoán
+        with st.spinner("🔍 Đang phân tích..."):
+            result, confidence = predict_image(tmp_path)
+            st.success(f"✅ Kết quả: **{result}**")
+            st.info(f"🔒 Độ tin cậy: **{confidence:.2f}%**")
+
+    except Exception as e:
+        st.error(f"❌ Lỗi: {e}")

cat_dog_resnet18.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d1a6e50bc25ade87fcd24fafcf3d5980069ae27747cd31e289740665ecd469b
+size 44792236

dataset_prep_resnet18.py

@@ -0,0 +1,65 @@
+import torch
+from torchvision import transforms, datasets
+from torch.utils.data import DataLoader
+from PIL import Image
+import os
+
+# Hàm kiểm tra ảnh lỗi
+def is_valid_image(filepath):
+    try:
+        with Image.open(filepath) as img:
+            img.verify()
+            img = Image.open(filepath).convert('RGB')  # thử load RGB luôn
+        return True
+    except:
+        print(f"[!] Ảnh lỗi hoặc không hợp lệ: {filepath}")
+        return False
+
+# Hàm dọn dữ liệu lỗi trong thư mục
+def clean_dataset(directory):
+    for class_dir in os.listdir(directory):
+        class_path = os.path.join(directory, class_dir)
+        if os.path.isdir(class_path):
+            for img_name in os.listdir(class_path):
+                img_path = os.path.join(class_path, img_name)
+                if not is_valid_image(img_path):
+                    os.remove(img_path)
+
+# Gọi dọn ảnh lỗi trước khi tạo dataset
+def get_data_loaders(data_dir='./data', batch_size=32):
+    print("🧹 Đang kiểm tra và loại bỏ ảnh lỗi...")
+    clean_dataset(os.path.join(data_dir, 'train'))
+    clean_dataset(os.path.join(data_dir, 'val'))
+    clean_dataset(os.path.join(data_dir, 'test'))
+
+    # Transform đúng chuẩn cho ResNet
+    train_transform = transforms.Compose([
+        transforms.RandomResizedCrop(224),
+        transforms.RandomHorizontalFlip(p=0.5),
+        transforms.RandomRotation(15),
+        transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                             std=[0.229, 0.224, 0.225])
+    ])
+
+    val_transform = transforms.Compose([
+        transforms.Resize(256),
+        transforms.CenterCrop(224),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                             std=[0.229, 0.224, 0.225])
+    ])
+
+    train_dataset = datasets.ImageFolder(root=os.path.join(data_dir, 'train'), transform=train_transform)
+    val_dataset = datasets.ImageFolder(root=os.path.join(data_dir, 'val'), transform=val_transform)
+    test_dataset = datasets.ImageFolder(root=os.path.join(data_dir, 'test'), transform=val_transform)
+
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
+    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
+
+    print("📂 Nhãn lớp:", train_dataset.classes)
+    print(f"🖼️ Số lượng ảnh: train = {len(train_dataset)}, val = {len(val_dataset)}, test = {len(test_dataset)}")
+
+    return train_loader, val_loader, test_loader

model_resnet18.py

@@ -0,0 +1,21 @@
+import torch.nn as nn
+from torchvision.models import resnet18, ResNet18_Weights
+
+class CatDogClassifier(nn.Module):
+    def __init__(self):
+        super(CatDogClassifier, self).__init__()
+        
+        # Sử dụng pretrained weights chuẩn (ImageNet)
+        weights = ResNet18_Weights.DEFAULT
+        self.base_model = resnet18(weights=weights)
+
+        # Đóng băng toàn bộ layer (chỉ fine-tune fc layer)
+        for param in self.base_model.parameters():
+            param.requires_grad = False
+
+        # Thay thế lớp fully connected cuối bằng lớp phân loại 2 lớp
+        num_ftrs = self.base_model.fc.in_features
+        self.base_model.fc = nn.Linear(num_ftrs, 2)
+
+    def forward(self, x):
+        return self.base_model(x)

predict_resnet18.py

@@ -0,0 +1,59 @@
+import torch
+from torchvision import transforms
+from PIL import Image
+from model_resnet18 import CatDogClassifier  # dùng ResNet18
+import json
+import os
+
+# Định nghĩa transform giống như lúc huấn luyện với ResNet18
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
+
+# Hàm dự đoán ảnh
+def predict_image(image_path):
+    try:
+        # Kiểm tra tệp tồn tại
+        if not os.path.exists(image_path):
+            raise FileNotFoundError(f"Không tìm thấy ảnh: {image_path}")
+
+        # Tải model ResNet18
+        model = CatDogClassifier()
+        model.load_state_dict(torch.load("cat_dog_resnet18.pth", map_location=torch.device("cpu")))
+        model.eval()
+
+        # Load class_to_idx
+        with open("class_to_idx.json", "r") as f:
+            class_to_idx = json.load(f)
+        idx_to_class = {v: k for k, v in class_to_idx.items()}
+
+        # Xử lý ảnh
+        image = Image.open(image_path).convert("RGB")
+        image_tensor = transform(image).unsqueeze(0)  # [1, 3, 224, 224]
+
+        # Dự đoán
+        with torch.no_grad():
+            outputs = model(image_tensor)
+            probs = torch.nn.functional.softmax(outputs, dim=1)
+            _, pred = torch.max(probs, 1)
+            confidence = probs[0][pred.item()].item()
+
+        label = idx_to_class[pred.item()]
+        emoji = "🐱" if "cat" in label.lower() else "🐶"
+        return f"{label.capitalize()} {emoji}", confidence * 100
+
+    except Exception as e:
+        raise RuntimeError(f"Lỗi khi dự đoán: {str(e)}")
+
+# Chạy thử khi chạy trực tiếp
+if __name__ == "__main__":
+    image_path = r"C:\Users\ADMIN\Desktop\Xulyanh2\data\test\cat\1359.jpg"
+    try:
+        result, confidence = predict_image(image_path)
+        print(f"Kết quả: {result} (độ tin cậy: {confidence:.2f}%)")
+    except Exception as e:
+        print(f"Lỗi: {e}")

train_resnet18.py

@@ -0,0 +1,119 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from tqdm import tqdm
+from model_resnet18 import CatDogClassifier
+from dataset_prep_resnet18 import get_data_loaders
+import copy
+import os
+import json
+
+# --- Cấu hình ---
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+EPOCHS = 20
+BATCH_SIZE = 32
+LEARNING_RATE = 0.001
+DATA_DIR = './data'
+PATIENCE = 5  # cho EarlyStopping
+
+def train():
+    # Tải dữ liệu
+    train_loader, val_loader, test_loader = get_data_loaders(data_dir=DATA_DIR, batch_size=BATCH_SIZE)
+
+    # Khởi tạo mô hình (ResNet18)
+    model = CatDogClassifier().to(DEVICE)
+
+    # Loss và Optimizer
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
+
+    # Lưu class_to_idx để dùng khi predict
+    class_to_idx = train_loader.dataset.class_to_idx  # lấy từ ImageFolder
+    with open("class_to_idx.json", "w") as f:
+        json.dump(class_to_idx, f)
+
+    best_model_wts = copy.deepcopy(model.state_dict())
+    best_val_acc = 0.0
+    epochs_no_improve = 0
+
+    for epoch in range(EPOCHS):
+        print(f"\n📘 Epoch [{epoch+1}/{EPOCHS}]")
+        model.train()
+        running_loss = 0.0
+        correct, total = 0, 0
+
+        for images, labels in tqdm(train_loader, desc="Training"):
+            images, labels = images.to(DEVICE), labels.to(DEVICE)
+
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+            _, predicted = torch.max(outputs, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+        train_acc = 100. * correct / total
+        avg_train_loss = running_loss / len(train_loader)
+
+        # --- Validation ---
+        model.eval()
+        val_loss = 0.0
+        val_correct = 0
+        val_total = 0
+        with torch.no_grad():
+            for images, labels in val_loader:
+                images, labels = images.to(DEVICE), labels.to(DEVICE)
+                outputs = model(images)
+                loss = criterion(outputs, labels)
+                val_loss += loss.item()
+                _, predicted = torch.max(outputs, 1)
+                val_total += labels.size(0)
+                val_correct += (predicted == labels).sum().item()
+
+        val_acc = 100. * val_correct / val_total
+        avg_val_loss = val_loss / len(val_loader)
+
+        print(f"✅ Train Acc: {train_acc:.2f}% | Loss: {avg_train_loss:.4f}")
+        print(f"🧪 Val Acc:   {val_acc:.2f}% | Loss: {avg_val_loss:.4f}")
+
+        # --- ModelCheckpoint ---
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_model_wts = copy.deepcopy(model.state_dict())
+            torch.save(model.state_dict(), 'cat_dog_resnet18_ver2.pth')
+            print("💾 Đã lưu mô hình tốt nhất!")
+            epochs_no_improve = 0
+        else:
+            epochs_no_improve += 1
+            print(f"📌 Không cải thiện ({epochs_no_improve}/{PATIENCE})")
+
+        # --- EarlyStopping ---
+        if epochs_no_improve >= PATIENCE:
+            print("⏹️ Dừng sớm do không cải thiện validation accuracy.")
+            break
+
+    print(f"\n🎯 Huấn luyện hoàn tất. Val Acc tốt nhất: {best_val_acc:.2f}%")
+
+    # --- Test ---
+    model.load_state_dict(best_model_wts)
+    test_acc = evaluate(model, test_loader)
+    print(f"📊 Test Accuracy: {test_acc:.2f}%")
+
+def evaluate(model, loader):
+    model.eval()
+    correct, total = 0, 0
+    with torch.no_grad():
+        for images, labels in loader:
+            images, labels = images.to(DEVICE), labels.to(DEVICE)
+            outputs = model(images)
+            _, predicted = torch.max(outputs, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+    return 100. * correct / total
+
+if __name__ == '__main__':
+    train()