PawMatchAI / app.py
DawnC's picture
Update app.py
d96e417
raw
history blame
18.7 kB
import os
import numpy as np
import torch
import torch.nn as nn
import gradio as gr
from dataclasses import dataclass
from torchvision.models import efficientnet_v2_m, EfficientNet_V2_M_Weights
from torchvision.ops import nms, box_iou
import torch.nn.functional as F
from torchvision import transforms
from PIL import Image, ImageDraw, ImageFont, ImageFilter
from dog_database import get_dog_description
from breed_health_info import breed_health_info
from breed_noise_info import breed_noise_info
from scoring_calculation_system import UserPreferences
from recommendation_html_format import format_recommendation_html, get_breed_recommendations
from history_manager import UserHistoryManager
from search_history import create_history_tab, create_history_component
from styles import get_css_styles
from breed_detection import create_detection_tab
from breed_comparison import create_comparison_tab
from breed_recommendation import create_recommendation_tab
from html_templates import (
format_description_html,
format_single_dog_result,
format_multiple_breeds_result,
format_error_message,
format_warning_html,
format_multi_dog_container,
format_breed_details_html,
get_color_scheme,
get_akc_breeds_link
)
from urllib.parse import quote
from ultralytics import YOLO
import asyncio
import traceback
model_yolo = YOLO('yolov8l.pt')
history_manager = UserHistoryManager()
dog_breeds = ["Afghan_Hound", "African_Hunting_Dog", "Airedale", "American_Staffordshire_Terrier",
"Appenzeller", "Australian_Terrier", "Bedlington_Terrier", "Bernese_Mountain_Dog",
"Blenheim_Spaniel", "Border_Collie", "Border_Terrier", "Boston_Bull", "Bouvier_Des_Flandres",
"Brabancon_Griffon", "Brittany_Spaniel", "Cardigan", "Chesapeake_Bay_Retriever",
"Chihuahua", "Dandie_Dinmont", "Doberman", "English_Foxhound", "English_Setter",
"English_Springer", "EntleBucher", "Eskimo_Dog", "French_Bulldog", "German_Shepherd",
"German_Short-Haired_Pointer", "Gordon_Setter", "Great_Dane", "Great_Pyrenees",
"Greater_Swiss_Mountain_Dog", "Ibizan_Hound", "Irish_Setter", "Irish_Terrier",
"Irish_Water_Spaniel", "Irish_Wolfhound", "Italian_Greyhound", "Japanese_Spaniel",
"Kerry_Blue_Terrier", "Labrador_Retriever", "Lakeland_Terrier", "Leonberg", "Lhasa",
"Maltese_Dog", "Mexican_Hairless", "Newfoundland", "Norfolk_Terrier", "Norwegian_Elkhound",
"Norwich_Terrier", "Old_English_Sheepdog", "Pekinese", "Pembroke", "Pomeranian",
"Rhodesian_Ridgeback", "Rottweiler", "Saint_Bernard", "Saluki", "Samoyed",
"Scotch_Terrier", "Scottish_Deerhound", "Sealyham_Terrier", "Shetland_Sheepdog",
"Shih-Tzu", "Siberian_Husky", "Staffordshire_Bullterrier", "Sussex_Spaniel",
"Tibetan_Mastiff", "Tibetan_Terrier", "Walker_Hound", "Weimaraner",
"Welsh_Springer_Spaniel", "West_Highland_White_Terrier", "Yorkshire_Terrier",
"Affenpinscher", "Basenji", "Basset", "Beagle", "Black-and-Tan_Coonhound", "Bloodhound",
"Bluetick", "Borzoi", "Boxer", "Briard", "Bull_Mastiff", "Cairn", "Chow", "Clumber",
"Cocker_Spaniel", "Collie", "Curly-Coated_Retriever", "Dhole", "Dingo",
"Flat-Coated_Retriever", "Giant_Schnauzer", "Golden_Retriever", "Groenendael", "Keeshond",
"Kelpie", "Komondor", "Kuvasz", "Malamute", "Malinois", "Miniature_Pinscher",
"Miniature_Poodle", "Miniature_Schnauzer", "Otterhound", "Papillon", "Pug", "Redbone",
"Schipperke", "Silky_Terrier", "Soft-Coated_Wheaten_Terrier", "Standard_Poodle",
"Standard_Schnauzer", "Toy_Poodle", "Toy_Terrier", "Vizsla", "Whippet",
"Wire-Haired_Fox_Terrier"]
class MultiHeadAttention(nn.Module):
def __init__(self, in_dim, num_heads=8):
super().__init__()
self.num_heads = num_heads
self.head_dim = max(1, in_dim // num_heads)
self.scaled_dim = self.head_dim * num_heads
self.fc_in = nn.Linear(in_dim, self.scaled_dim)
self.query = nn.Linear(self.scaled_dim, self.scaled_dim)
self.key = nn.Linear(self.scaled_dim, self.scaled_dim)
self.value = nn.Linear(self.scaled_dim, self.scaled_dim)
self.fc_out = nn.Linear(self.scaled_dim, in_dim)
def forward(self, x):
N = x.shape[0]
x = self.fc_in(x)
q = self.query(x).view(N, self.num_heads, self.head_dim)
k = self.key(x).view(N, self.num_heads, self.head_dim)
v = self.value(x).view(N, self.num_heads, self.head_dim)
energy = torch.einsum("nqd,nkd->nqk", [q, k])
attention = F.softmax(energy / (self.head_dim ** 0.5), dim=2)
out = torch.einsum("nqk,nvd->nqd", [attention, v])
out = out.reshape(N, self.scaled_dim)
out = self.fc_out(out)
return out
class BaseModel(nn.Module):
def __init__(self, num_classes, device='cuda' if torch.cuda.is_available() else 'cpu'):
super().__init__()
self.device = device
self.backbone = efficientnet_v2_m(weights=EfficientNet_V2_M_Weights.IMAGENET1K_V1)
self.feature_dim = self.backbone.classifier[1].in_features
self.backbone.classifier = nn.Identity()
self.num_heads = max(1, min(8, self.feature_dim // 64))
self.attention = MultiHeadAttention(self.feature_dim, num_heads=self.num_heads)
self.classifier = nn.Sequential(
nn.LayerNorm(self.feature_dim),
nn.Dropout(0.3),
nn.Linear(self.feature_dim, num_classes)
)
self.to(device)
def forward(self, x):
x = x.to(self.device)
features = self.backbone(x)
attended_features = self.attention(features)
logits = self.classifier(attended_features)
return logits, attended_features
num_classes = 120
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = BaseModel(num_classes=num_classes, device=device)
checkpoint = torch.load('best_model_81_dog.pth', map_location=torch.device('cpu'))
model.load_state_dict(checkpoint['model_state_dict'])
# evaluation mode
model.eval()
# Image preprocessing function
def preprocess_image(image):
# If the image is numpy.ndarray turn into PIL.Image
if isinstance(image, np.ndarray):
image = Image.fromarray(image)
# Use torchvision.transforms to process images
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
return transform(image).unsqueeze(0)
async def predict_single_dog(image):
image_tensor = preprocess_image(image)
with torch.no_grad():
output = model(image_tensor)
logits = output[0] if isinstance(output, tuple) else output
probabilities = F.softmax(logits, dim=1)
topk_probs, topk_indices = torch.topk(probabilities, k=3)
top1_prob = topk_probs[0][0].item()
topk_breeds = [dog_breeds[idx.item()] for idx in topk_indices[0]]
# Calculate relative probabilities for display
raw_probs = [prob.item() for prob in topk_probs[0]]
sum_probs = sum(raw_probs)
relative_probs = [f"{(prob/sum_probs * 100):.2f}%" for prob in raw_probs]
return top1_prob, topk_breeds, relative_probs
async def detect_multiple_dogs(image, conf_threshold=0.3, iou_threshold=0.45):
results = model_yolo(image, conf=conf_threshold, iou=iou_threshold)[0]
dogs = []
boxes = []
for box in results.boxes:
if box.cls == 16: # COCO dataset class for dog is 16
xyxy = box.xyxy[0].tolist()
confidence = box.conf.item()
boxes.append((xyxy, confidence))
if not boxes:
dogs.append((image, 1.0, [0, 0, image.width, image.height]))
else:
nms_boxes = non_max_suppression(boxes, iou_threshold)
for box, confidence in nms_boxes:
x1, y1, x2, y2 = box
w, h = x2 - x1, y2 - y1
x1 = max(0, x1 - w * 0.05)
y1 = max(0, y1 - h * 0.05)
x2 = min(image.width, x2 + w * 0.05)
y2 = min(image.height, y2 + h * 0.05)
cropped_image = image.crop((x1, y1, x2, y2))
dogs.append((cropped_image, confidence, [x1, y1, x2, y2]))
return dogs
def non_max_suppression(boxes, iou_threshold):
keep = []
boxes = sorted(boxes, key=lambda x: x[1], reverse=True)
while boxes:
current = boxes.pop(0)
keep.append(current)
boxes = [box for box in boxes if calculate_iou(current[0], box[0]) < iou_threshold]
return keep
def calculate_iou(box1, box2):
x1 = max(box1[0], box2[0])
y1 = max(box1[1], box2[1])
x2 = min(box1[2], box2[2])
y2 = min(box1[3], box2[3])
intersection = max(0, x2 - x1) * max(0, y2 - y1)
area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
iou = intersection / float(area1 + area2 - intersection)
return iou
async def process_single_dog(image):
"""Process a single dog image and return breed predictions and HTML output."""
top1_prob, topk_breeds, relative_probs = await predict_single_dog(image)
# Case 1: Low confidence - unclear image or breed not in dataset
if top1_prob < 0.2:
error_message = format_warning_html(
'The image is unclear or the breed is not in the dataset. Please upload a clearer image of a dog.'
)
initial_state = {
"explanation": error_message,
"image": None,
"is_multi_dog": False
}
return error_message, None, initial_state
breed = topk_breeds[0]
# Case 2: High confidence - single breed result
if top1_prob >= 0.45:
description = get_dog_description(breed)
html_content = format_single_dog_result(breed, description)
initial_state = {
"explanation": html_content,
"image": image,
"is_multi_dog": False
}
return html_content, image, initial_state
# Case 3: Medium confidence - show top 3 breeds with relative probabilities
description = get_dog_description(breed)
breeds_html = format_multiple_breeds_result(
topk_breeds=topk_breeds,
relative_probs=relative_probs,
color='#34C759', # 使用單狗顏色
index=1, # 因為是單狗處理,所以index為1
get_dog_description=get_dog_description
)
initial_state = {
"explanation": breeds_html,
"image": image,
"is_multi_dog": False
}
return breeds_html, image, initial_state
def create_breed_comparison(breed1: str, breed2: str) -> dict:
breed1_info = get_dog_description(breed1)
breed2_info = get_dog_description(breed2)
# 標準化數值轉換
value_mapping = {
'Size': {'Small': 1, 'Medium': 2, 'Large': 3, 'Giant': 4},
'Exercise_Needs': {'Low': 1, 'Moderate': 2, 'High': 3, 'Very High': 4},
'Care_Level': {'Low': 1, 'Moderate': 2, 'High': 3},
'Grooming_Needs': {'Low': 1, 'Moderate': 2, 'High': 3}
}
comparison_data = {
breed1: {},
breed2: {}
}
for breed, info in [(breed1, breed1_info), (breed2, breed2_info)]:
comparison_data[breed] = {
'Size': value_mapping['Size'].get(info['Size'], 2), # 預設 Medium
'Exercise_Needs': value_mapping['Exercise_Needs'].get(info['Exercise Needs'], 2), # 預設 Moderate
'Care_Level': value_mapping['Care_Level'].get(info['Care Level'], 2),
'Grooming_Needs': value_mapping['Grooming_Needs'].get(info['Grooming Needs'], 2),
'Good_with_Children': info['Good with Children'] == 'Yes',
'Original_Data': info
}
return comparison_data
async def predict(image):
"""
Main prediction function that handles both single and multiple dog detection.
Args:
image: PIL Image or numpy array
Returns:
tuple: (html_output, annotated_image, initial_state)
"""
if image is None:
return format_warning_html("Please upload an image to start."), None, None
try:
if isinstance(image, np.ndarray):
image = Image.fromarray(image)
# Detect dogs in the image
dogs = await detect_multiple_dogs(image)
color_scheme = get_color_scheme(len(dogs) == 1)
# Prepare for annotation
annotated_image = image.copy()
draw = ImageDraw.Draw(annotated_image)
try:
font = ImageFont.truetype("arial.ttf", 24)
except:
font = ImageFont.load_default()
dogs_info = ""
# Process each detected dog
for i, (cropped_image, detection_confidence, box) in enumerate(dogs):
color = color_scheme if len(dogs) == 1 else color_scheme[i % len(color_scheme)]
# Draw box and label on image
draw.rectangle(box, outline=color, width=4)
label = f"Dog {i+1}"
label_bbox = draw.textbbox((0, 0), label, font=font)
label_width = label_bbox[2] - label_bbox[0]
label_height = label_bbox[3] - label_bbox[1]
# Draw label background and text
label_x = box[0] + 5
label_y = box[1] + 5
draw.rectangle(
[label_x - 2, label_y - 2, label_x + label_width + 4, label_y + label_height + 4],
fill='white',
outline=color,
width=2
)
draw.text((label_x, label_y), label, fill=color, font=font)
# Predict breed
top1_prob, topk_breeds, relative_probs = await predict_single_dog(cropped_image)
combined_confidence = detection_confidence * top1_prob
# Format results based on confidence
if combined_confidence < 0.2:
dogs_info += format_error_message(color, i+1)
elif top1_prob >= 0.45:
breed = topk_breeds[0]
description = get_dog_description(breed)
dogs_info += format_single_dog_result(breed, description, color)
else:
dogs_info += format_multiple_breeds_result(
topk_breeds,
relative_probs,
color,
i+1,
get_dog_description
)
# Wrap final HTML output
html_output = format_multi_dog_container(dogs_info)
# Prepare initial state
initial_state = {
"dogs_info": dogs_info,
"image": annotated_image,
"is_multi_dog": len(dogs) > 1,
"html_output": html_output
}
return html_output, annotated_image, initial_state
except Exception as e:
error_msg = f"An error occurred: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
print(error_msg)
return format_warning_html(error_msg), None, None
def show_details_html(choice, previous_output, initial_state):
"""
Generate detailed HTML view for a selected breed.
Args:
choice: str, Selected breed option
previous_output: str, Previous HTML output
initial_state: dict, Current state information
Returns:
tuple: (html_output, gradio_update, updated_state)
"""
if not choice:
return previous_output, gr.update(visible=True), initial_state
try:
breed = choice.split("More about ")[-1]
description = get_dog_description(breed)
html_output = format_breed_details_html(description, breed)
# Update state
initial_state["current_description"] = html_output
initial_state["original_buttons"] = initial_state.get("buttons", [])
return html_output, gr.update(visible=True), initial_state
except Exception as e:
error_msg = f"An error occurred while showing details: {e}"
print(error_msg)
return format_warning_html(error_msg), gr.update(visible=True), initial_state
def main():
with gr.Blocks(css=get_css_styles()) as iface:
# Header HTML
gr.HTML("""
<header style='text-align: center; padding: 20px; margin-bottom: 20px;'>
<h1 style='font-size: 2.5em; margin-bottom: 10px; color: #2D3748;'>
🐾 PawMatch AI
</h1>
<h2 style='font-size: 1.2em; font-weight: normal; color: #4A5568; margin-top: 5px;'>
Your Smart Dog Breed Guide
</h2>
<div style='width: 50px; height: 3px; background: linear-gradient(90deg, #4299e1, #48bb78); margin: 15px auto;'></div>
<p style='color: #718096; font-size: 0.9em;'>
Powered by AI • Breed Recognition • Smart Matching • Companion Guide
</p>
</header>
""")
# 先創建歷史組件實例(但不創建標籤頁)
history_component = create_history_component()
with gr.Tabs():
# 1. 品種檢測標籤頁
example_images = [
'Border_Collie.jpg',
'Golden_Retriever.jpeg',
'Saint_Bernard.jpeg',
'Samoyed.jpg',
'French_Bulldog.jpeg'
]
detection_components = create_detection_tab(predict, example_images)
# 2. 品種比較標籤頁
comparison_components = create_comparison_tab(
dog_breeds=dog_breeds,
get_dog_description=get_dog_description,
breed_health_info=breed_health_info,
breed_noise_info=breed_noise_info
)
# 3. 品種推薦標籤頁
recommendation_components = create_recommendation_tab(
UserPreferences=UserPreferences,
get_breed_recommendations=get_breed_recommendations,
format_recommendation_html=format_recommendation_html,
history_component=history_component
)
# 4. 最後創建歷史記錄標籤頁
create_history_tab(history_component)
# Footer
gr.HTML('''
For more details on this project and other work, feel free to visit my GitHub
<a href="https://github.com/Eric-Chung-0511/Learning-Record/tree/main/Data%20Science%20Projects/Dog_Breed_Classifier">
Dog Breed Classifier
</a>
''')
return iface
if __name__ == "__main__":
iface = main()
iface.launch(share=True, debug=True)