|
|
@@ -1,372 +1,4 @@
|
|
|
|
|
|
-# # ==================== visual_processing_service.py (FIXED - Dynamic Detection) ====================
|
|
|
-# import torch
|
|
|
-# import cv2
|
|
|
-# import numpy as np
|
|
|
-# import requests
|
|
|
-# from io import BytesIO
|
|
|
-# from PIL import Image
|
|
|
-# from typing import Dict, List, Optional, Tuple
|
|
|
-# import logging
|
|
|
-# from transformers import CLIPProcessor, CLIPModel
|
|
|
-# from sklearn.cluster import KMeans
|
|
|
-
|
|
|
-# logger = logging.getLogger(__name__)
|
|
|
-
|
|
|
-
|
|
|
-# class VisualProcessingService:
|
|
|
-# """Service for extracting visual attributes from product images using CLIP."""
|
|
|
-
|
|
|
-# # Class-level caching (shared across instances)
|
|
|
-# _clip_model = None
|
|
|
-# _clip_processor = None
|
|
|
-# _device = None
|
|
|
-
|
|
|
-# # Define category-specific attributes
|
|
|
-# CATEGORY_ATTRIBUTES = {
|
|
|
-# "clothing": {
|
|
|
-# "products": ["t-shirt", "shirt", "dress", "pants", "jeans", "shorts",
|
|
|
-# "skirt", "jacket", "coat", "sweater", "hoodie", "top", "blouse"],
|
|
|
-# "attributes": {
|
|
|
-# "pattern": ["solid color", "striped", "checkered", "graphic print", "floral", "geometric", "plain"],
|
|
|
-# "material": ["cotton", "polyester", "denim", "leather", "silk", "wool", "linen", "blend"],
|
|
|
-# "style": ["casual", "formal", "sporty", "streetwear", "elegant", "vintage", "bohemian"],
|
|
|
-# "fit": ["slim fit", "regular fit", "loose fit", "oversized", "tailored"],
|
|
|
-# "neckline": ["crew neck", "v-neck", "round neck", "collar", "scoop neck"],
|
|
|
-# "sleeve_type": ["short sleeve", "long sleeve", "sleeveless", "3/4 sleeve"],
|
|
|
-# "closure_type": ["button", "zipper", "pull-on", "snap", "tie"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-# "tools": {
|
|
|
-# "products": ["screwdriver", "hammer", "wrench", "pliers", "drill", "saw",
|
|
|
-# "measuring tape", "level", "chisel", "file"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["steel", "aluminum", "plastic", "wood", "rubber", "chrome"],
|
|
|
-# "type": ["manual", "electric", "pneumatic", "cordless", "corded"],
|
|
|
-# "finish": ["chrome plated", "powder coated", "stainless steel", "painted"],
|
|
|
-# "handle_type": ["rubber grip", "plastic", "wooden", "cushioned", "ergonomic"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-# "electronics": {
|
|
|
-# "products": ["phone", "laptop", "tablet", "headphones", "speaker", "camera",
|
|
|
-# "smartwatch", "charger", "mouse", "keyboard"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["plastic", "metal", "glass", "aluminum", "rubber"],
|
|
|
-# "style": ["modern", "minimalist", "sleek", "industrial", "vintage"],
|
|
|
-# "finish": ["matte", "glossy", "metallic", "textured"],
|
|
|
-# "connectivity": ["wireless", "wired", "bluetooth", "USB"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-# "furniture": {
|
|
|
-# "products": ["chair", "table", "sofa", "bed", "desk", "shelf", "cabinet",
|
|
|
-# "dresser", "bench", "stool"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["wood", "metal", "glass", "plastic", "fabric", "leather"],
|
|
|
-# "style": ["modern", "traditional", "industrial", "rustic", "contemporary", "vintage"],
|
|
|
-# "finish": ["natural wood", "painted", "stained", "laminated", "upholstered"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-# "home_decor": {
|
|
|
-# "products": ["painting", "canvas", "wall art", "frame", "vase", "lamp",
|
|
|
-# "mirror", "clock", "sculpture", "poster"],
|
|
|
-# "attributes": {
|
|
|
-# "style": ["modern", "abstract", "traditional", "contemporary", "vintage", "minimalist"],
|
|
|
-# "material": ["canvas", "wood", "metal", "glass", "ceramic", "paper"],
|
|
|
-# "finish": ["glossy", "matte", "textured", "framed", "gallery wrapped"],
|
|
|
-# "theme": ["nature", "geometric", "floral", "landscape", "portrait", "abstract"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-# "kitchen": {
|
|
|
-# "products": ["pot", "pan", "knife", "utensil", "plate", "bowl", "cup",
|
|
|
-# "appliance", "cutting board", "container"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["stainless steel", "aluminum", "ceramic", "glass", "plastic", "wood"],
|
|
|
-# "finish": ["non-stick", "stainless", "enameled", "anodized"],
|
|
|
-# "type": ["manual", "electric", "dishwasher safe"]
|
|
|
-# }
|
|
|
-# }
|
|
|
-# }
|
|
|
-
|
|
|
-# def __init__(self):
|
|
|
-# pass
|
|
|
-
|
|
|
-# @classmethod
|
|
|
-# def _get_device(cls):
|
|
|
-# """Get optimal device."""
|
|
|
-# if cls._device is None:
|
|
|
-# cls._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
|
|
-# logger.info(f"Visual Processing using device: {cls._device}")
|
|
|
-# return cls._device
|
|
|
-
|
|
|
-# @classmethod
|
|
|
-# def _get_clip_model(cls):
|
|
|
-# """Lazy load CLIP model with class-level caching."""
|
|
|
-# if cls._clip_model is None:
|
|
|
-# logger.info("Loading CLIP model (this may take a few minutes on first use)...")
|
|
|
-# cls._clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
|
|
|
-# cls._clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
|
|
|
-
|
|
|
-# device = cls._get_device()
|
|
|
-# cls._clip_model.to(device)
|
|
|
-# cls._clip_model.eval()
|
|
|
-
|
|
|
-# logger.info("✓ CLIP model loaded successfully")
|
|
|
-# return cls._clip_model, cls._clip_processor
|
|
|
-
|
|
|
-# def download_image(self, image_url: str) -> Optional[Image.Image]:
|
|
|
-# """Download image from URL."""
|
|
|
-# try:
|
|
|
-# response = requests.get(image_url, timeout=10)
|
|
|
-# response.raise_for_status()
|
|
|
-# image = Image.open(BytesIO(response.content)).convert('RGB')
|
|
|
-# return image
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error downloading image from {image_url}: {str(e)}")
|
|
|
-# return None
|
|
|
-
|
|
|
-# def extract_dominant_colors(self, image: Image.Image, n_colors: int = 3) -> List[Dict]:
|
|
|
-# """Extract dominant colors using K-means."""
|
|
|
-# try:
|
|
|
-# # Resize for faster processing
|
|
|
-# img_small = image.resize((150, 150))
|
|
|
-# img_array = np.array(img_small)
|
|
|
-# pixels = img_array.reshape(-1, 3)
|
|
|
-
|
|
|
-# # K-means clustering
|
|
|
-# kmeans = KMeans(n_clusters=n_colors, random_state=42, n_init=5)
|
|
|
-# kmeans.fit(pixels)
|
|
|
-
|
|
|
-# colors = []
|
|
|
-# labels_counts = np.bincount(kmeans.labels_)
|
|
|
-
|
|
|
-# for i, center in enumerate(kmeans.cluster_centers_):
|
|
|
-# rgb = tuple(center.astype(int))
|
|
|
-# color_name = self._get_color_name_simple(rgb)
|
|
|
-# percentage = float(labels_counts[i] / len(kmeans.labels_) * 100)
|
|
|
-
|
|
|
-# colors.append({
|
|
|
-# "name": color_name,
|
|
|
-# "rgb": rgb,
|
|
|
-# "percentage": percentage
|
|
|
-# })
|
|
|
-
|
|
|
-# colors.sort(key=lambda x: x['percentage'], reverse=True)
|
|
|
-# return colors
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error extracting colors: {str(e)}")
|
|
|
-# return []
|
|
|
-
|
|
|
-# def _get_color_name_simple(self, rgb: Tuple[int, int, int]) -> str:
|
|
|
-# """
|
|
|
-# Simple color name detection without webcolors dependency.
|
|
|
-# Maps RGB to basic color names.
|
|
|
-# """
|
|
|
-# r, g, b = rgb
|
|
|
-
|
|
|
-# # Define basic color ranges
|
|
|
-# colors = {
|
|
|
-# 'black': (r < 50 and g < 50 and b < 50),
|
|
|
-# 'white': (r > 200 and g > 200 and b > 200),
|
|
|
-# 'gray': (abs(r - g) < 30 and abs(g - b) < 30 and abs(r - b) < 30 and 50 <= r <= 200),
|
|
|
-# 'red': (r > 150 and g < 100 and b < 100),
|
|
|
-# 'green': (g > 150 and r < 100 and b < 100),
|
|
|
-# 'blue': (b > 150 and r < 100 and g < 100),
|
|
|
-# 'yellow': (r > 200 and g > 200 and b < 100),
|
|
|
-# 'orange': (r > 200 and 100 < g < 200 and b < 100),
|
|
|
-# 'purple': (r > 100 and b > 100 and g < 100),
|
|
|
-# 'pink': (r > 200 and 100 < g < 200 and 100 < b < 200),
|
|
|
-# 'brown': (50 < r < 150 and 30 < g < 100 and b < 80),
|
|
|
-# 'cyan': (r < 100 and g > 150 and b > 150),
|
|
|
-# }
|
|
|
-
|
|
|
-# for color_name, condition in colors.items():
|
|
|
-# if condition:
|
|
|
-# return color_name
|
|
|
-
|
|
|
-# # Default fallback
|
|
|
-# if r > g and r > b:
|
|
|
-# return 'red'
|
|
|
-# elif g > r and g > b:
|
|
|
-# return 'green'
|
|
|
-# elif b > r and b > g:
|
|
|
-# return 'blue'
|
|
|
-# else:
|
|
|
-# return 'gray'
|
|
|
-
|
|
|
-# def classify_with_clip(
|
|
|
-# self,
|
|
|
-# image: Image.Image,
|
|
|
-# candidates: List[str],
|
|
|
-# attribute_name: str,
|
|
|
-# confidence_threshold: float = 0.15
|
|
|
-# ) -> Dict:
|
|
|
-# """Use CLIP to classify image against candidate labels."""
|
|
|
-# try:
|
|
|
-# model, processor = self._get_clip_model()
|
|
|
-# device = self._get_device()
|
|
|
-
|
|
|
-# # Prepare inputs
|
|
|
-# inputs = processor(
|
|
|
-# text=candidates,
|
|
|
-# images=image,
|
|
|
-# return_tensors="pt",
|
|
|
-# padding=True
|
|
|
-# )
|
|
|
-
|
|
|
-# # Move to device
|
|
|
-# inputs = {k: v.to(device) for k, v in inputs.items()}
|
|
|
-
|
|
|
-# # Get predictions
|
|
|
-# with torch.no_grad():
|
|
|
-# outputs = model(**inputs)
|
|
|
-# logits_per_image = outputs.logits_per_image
|
|
|
-# probs = logits_per_image.softmax(dim=1).cpu()
|
|
|
-
|
|
|
-# # Get top predictions
|
|
|
-# top_k = min(3, len(candidates))
|
|
|
-# top_probs, top_indices = torch.topk(probs[0], k=top_k)
|
|
|
-
|
|
|
-# results = []
|
|
|
-# for prob, idx in zip(top_probs, top_indices):
|
|
|
-# if prob.item() > confidence_threshold:
|
|
|
-# results.append({
|
|
|
-# "value": candidates[idx.item()],
|
|
|
-# "confidence": float(prob.item())
|
|
|
-# })
|
|
|
-
|
|
|
-# return {
|
|
|
-# "attribute": attribute_name,
|
|
|
-# "predictions": results
|
|
|
-# }
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error in CLIP classification for {attribute_name}: {str(e)}")
|
|
|
-# return {"attribute": attribute_name, "predictions": []}
|
|
|
-
|
|
|
-# def detect_product_category(self, image: Image.Image) -> Tuple[str, float]:
|
|
|
-# """
|
|
|
-# First detect which category the product belongs to.
|
|
|
-# Returns: (category_name, confidence)
|
|
|
-# """
|
|
|
-# # Get all product types from all categories
|
|
|
-# all_categories = []
|
|
|
-# category_map = {}
|
|
|
-
|
|
|
-# for category, data in self.CATEGORY_ATTRIBUTES.items():
|
|
|
-# for product in data["products"]:
|
|
|
-# all_categories.append(f"a photo of a {product}")
|
|
|
-# category_map[f"a photo of a {product}"] = category
|
|
|
-
|
|
|
-# # Classify
|
|
|
-# result = self.classify_with_clip(image, all_categories, "category_detection", confidence_threshold=0.10)
|
|
|
-
|
|
|
-# if result["predictions"]:
|
|
|
-# best_match = result["predictions"][0]
|
|
|
-# detected_category = category_map[best_match["value"]]
|
|
|
-# product_type = best_match["value"].replace("a photo of a ", "")
|
|
|
-# confidence = best_match["confidence"]
|
|
|
-
|
|
|
-# logger.info(f"Detected category: {detected_category}, product: {product_type}, confidence: {confidence:.3f}")
|
|
|
-# return detected_category, product_type, confidence
|
|
|
-
|
|
|
-# return "unknown", "unknown", 0.0
|
|
|
-
|
|
|
-# def process_image(
|
|
|
-# self,
|
|
|
-# image_url: str,
|
|
|
-# product_type_hint: Optional[str] = None
|
|
|
-# ) -> Dict:
|
|
|
-# """
|
|
|
-# Main method to process image and extract visual attributes.
|
|
|
-# Now dynamically detects product category first.
|
|
|
-# """
|
|
|
-# import time
|
|
|
-# start_time = time.time()
|
|
|
-
|
|
|
-# try:
|
|
|
-# # Download image
|
|
|
-# image = self.download_image(image_url)
|
|
|
-# if image is None:
|
|
|
-# return {
|
|
|
-# "visual_attributes": {},
|
|
|
-# "error": "Failed to download image"
|
|
|
-# }
|
|
|
-
|
|
|
-# visual_attributes = {}
|
|
|
-# detailed_predictions = {}
|
|
|
-
|
|
|
-# # Step 1: Detect product category
|
|
|
-# detected_category, detected_product_type, category_confidence = self.detect_product_category(image)
|
|
|
-
|
|
|
-# # If confidence is too low, return minimal info
|
|
|
-# if category_confidence < 0.10:
|
|
|
-# logger.warning(f"Low confidence in category detection ({category_confidence:.3f}). Returning basic attributes only.")
|
|
|
-# colors = self.extract_dominant_colors(image, n_colors=3)
|
|
|
-# if colors:
|
|
|
-# visual_attributes["primary_color"] = colors[0]["name"]
|
|
|
-# visual_attributes["color_palette"] = [c["name"] for c in colors]
|
|
|
-
|
|
|
-# return {
|
|
|
-# "visual_attributes": visual_attributes,
|
|
|
-# "category_confidence": category_confidence,
|
|
|
-# "processing_time": round(time.time() - start_time, 2)
|
|
|
-# }
|
|
|
-
|
|
|
-# # Add detected product type
|
|
|
-# visual_attributes["product_type"] = detected_product_type
|
|
|
-# visual_attributes["category"] = detected_category
|
|
|
-
|
|
|
-# # Step 2: Extract color (universal attribute)
|
|
|
-# colors = self.extract_dominant_colors(image, n_colors=3)
|
|
|
-# if colors:
|
|
|
-# visual_attributes["primary_color"] = colors[0]["name"]
|
|
|
-# visual_attributes["color_palette"] = [c["name"] for c in colors]
|
|
|
-
|
|
|
-# # Step 3: Extract category-specific attributes
|
|
|
-# if detected_category in self.CATEGORY_ATTRIBUTES:
|
|
|
-# category_config = self.CATEGORY_ATTRIBUTES[detected_category]
|
|
|
-
|
|
|
-# for attr_name, attr_values in category_config["attributes"].items():
|
|
|
-# # Use higher confidence threshold for category-specific attributes
|
|
|
-# result = self.classify_with_clip(image, attr_values, attr_name, confidence_threshold=0.20)
|
|
|
-
|
|
|
-# if result["predictions"]:
|
|
|
-# # Only add if confidence is reasonable
|
|
|
-# best_prediction = result["predictions"][0]
|
|
|
-# if best_prediction["confidence"] > 0.20:
|
|
|
-# visual_attributes[attr_name] = best_prediction["value"]
|
|
|
-# detailed_predictions[attr_name] = result
|
|
|
-
|
|
|
-# processing_time = time.time() - start_time
|
|
|
-
|
|
|
-# return {
|
|
|
-# "visual_attributes": visual_attributes,
|
|
|
-# "detailed_predictions": detailed_predictions,
|
|
|
-# "category_confidence": category_confidence,
|
|
|
-# "processing_time": round(processing_time, 2)
|
|
|
-# }
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error processing image: {str(e)}")
|
|
|
-# return {
|
|
|
-# "visual_attributes": {},
|
|
|
-# "error": str(e),
|
|
|
-# "processing_time": round(time.time() - start_time, 2)
|
|
|
-# }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
# ==================== visual_processing_service.py (FIXED - Smart Subcategory Detection) ====================
|
|
|
import torch
|
|
|
import numpy as np
|
|
|
@@ -589,57 +221,6 @@ class VisualProcessingService:
|
|
|
return 'blue'
|
|
|
else:
|
|
|
return 'gray'
|
|
|
-
|
|
|
- # def classify_with_clip(
|
|
|
- # self,
|
|
|
- # image: Image.Image,
|
|
|
- # candidates: List[str],
|
|
|
- # attribute_name: str,
|
|
|
- # confidence_threshold: float = 0.15
|
|
|
- # ) -> Dict:
|
|
|
- # """Use CLIP to classify image against candidate labels."""
|
|
|
- # try:
|
|
|
- # model, processor = self._get_clip_model()
|
|
|
- # device = self._get_device()
|
|
|
-
|
|
|
- # # Prepare inputs
|
|
|
- # inputs = processor(
|
|
|
- # text=candidates,
|
|
|
- # images=image,
|
|
|
- # return_tensors="pt",
|
|
|
- # padding=True
|
|
|
- # )
|
|
|
-
|
|
|
- # # Move to device
|
|
|
- # inputs = {k: v.to(device) for k, v in inputs.items()}
|
|
|
-
|
|
|
- # # Get predictions
|
|
|
- # with torch.no_grad():
|
|
|
- # outputs = model(**inputs)
|
|
|
- # logits_per_image = outputs.logits_per_image
|
|
|
- # probs = logits_per_image.softmax(dim=1).cpu()
|
|
|
-
|
|
|
- # # Get top predictions
|
|
|
- # top_k = min(3, len(candidates))
|
|
|
- # top_probs, top_indices = torch.topk(probs[0], k=top_k)
|
|
|
-
|
|
|
- # results = []
|
|
|
- # for prob, idx in zip(top_probs, top_indices):
|
|
|
- # if prob.item() > confidence_threshold:
|
|
|
- # results.append({
|
|
|
- # "value": candidates[idx.item()],
|
|
|
- # "confidence": round(float(prob.item()), 3)
|
|
|
- # })
|
|
|
-
|
|
|
- # return {
|
|
|
- # "attribute": attribute_name,
|
|
|
- # "predictions": results
|
|
|
- # }
|
|
|
-
|
|
|
- # except Exception as e:
|
|
|
- # logger.error(f"Error in CLIP classification for {attribute_name}: {str(e)}")
|
|
|
- # return {"attribute": attribute_name, "predictions": []}
|
|
|
-
|
|
|
|
|
|
def classify_with_clip(
|
|
|
self,
|
|
|
@@ -892,1199 +473,3 @@ class VisualProcessingService:
|
|
|
}
|
|
|
|
|
|
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-# # ==================== visual_processing_service_enhanced.py ====================
|
|
|
-# """
|
|
|
-# Enhanced Visual Processing Service combining CLIP's speed with BLIP-2's comprehensive taxonomy.
|
|
|
-
|
|
|
-# Features:
|
|
|
-# - Fast CLIP-based classification
|
|
|
-# - 70+ product categories across multiple domains
|
|
|
-# - Two-stage classification with validation
|
|
|
-# - Enhanced color normalization
|
|
|
-# - Category-specific attribute detection
|
|
|
-# - Confidence-based fallback mechanisms
|
|
|
-# - Optional center cropping for better focus
|
|
|
-
|
|
|
-# Usage:
|
|
|
-# service = VisualProcessingService()
|
|
|
-# result = service.process_image("https://example.com/product.jpg")
|
|
|
-# """
|
|
|
-
|
|
|
-# import torch
|
|
|
-# import cv2
|
|
|
-# import numpy as np
|
|
|
-# import requests
|
|
|
-# from io import BytesIO
|
|
|
-# from PIL import Image
|
|
|
-# from typing import Dict, List, Optional, Tuple
|
|
|
-# import logging
|
|
|
-# from transformers import CLIPProcessor, CLIPModel
|
|
|
-# from sklearn.cluster import KMeans
|
|
|
-
|
|
|
-# logger = logging.getLogger(__name__)
|
|
|
-
|
|
|
-
|
|
|
-# class VisualProcessingService:
|
|
|
-# """Enhanced service for extracting visual attributes from product images using CLIP."""
|
|
|
-
|
|
|
-# # Class-level caching (shared across instances)
|
|
|
-# _clip_model = None
|
|
|
-# _clip_processor = None
|
|
|
-# _device = None
|
|
|
-
|
|
|
-# # ==================== EXPANDED TAXONOMY ====================
|
|
|
-
|
|
|
-# # Base color vocabulary
|
|
|
-# COLORS = ["black", "white", "red", "blue", "green", "yellow", "gray",
|
|
|
-# "brown", "pink", "purple", "orange", "beige", "navy", "teal"]
|
|
|
-
|
|
|
-# # Pattern vocabulary
|
|
|
-# PATTERNS = ["solid", "striped", "checked", "plaid", "floral", "graphic",
|
|
|
-# "polka dot", "camo", "tie-dye", "abstract", "geometric"]
|
|
|
-
|
|
|
-# # Material vocabulary (extended)
|
|
|
-# MATERIALS = ["cotton", "polyester", "denim", "leather", "wool", "canvas",
|
|
|
-# "silicone", "metal", "fabric", "rubber", "plastic", "wood",
|
|
|
-# "glass", "ceramic", "steel", "foam", "aluminum", "carbon fiber"]
|
|
|
-
|
|
|
-# # Style vocabulary
|
|
|
-# STYLES = ["casual", "formal", "sporty", "streetwear", "elegant", "vintage",
|
|
|
-# "modern", "bohemian", "minimalist", "industrial", "rustic", "contemporary"]
|
|
|
-
|
|
|
-# # Fit vocabulary
|
|
|
-# FITS = ["slim fit", "regular fit", "loose fit", "oversized", "tailored",
|
|
|
-# "relaxed", "athletic fit"]
|
|
|
-
|
|
|
-# # Brand vocabulary (common marketplace brands)
|
|
|
-# BRANDS = ["nike", "adidas", "sony", "samsung", "apple", "generic", "lego",
|
|
|
-# "hasbro", "lg", "panasonic", "microsoft"]
|
|
|
-
|
|
|
-# # Age group vocabulary
|
|
|
-# AGE_GROUPS = ["baby", "toddler", "child", "teen", "adult", "all ages"]
|
|
|
-
|
|
|
-# # Comprehensive category-specific attributes
|
|
|
-# CATEGORY_ATTRIBUTES = {
|
|
|
-# # ==================== CLOTHING ====================
|
|
|
-# "clothing": {
|
|
|
-# "products": ["t-shirt", "shirt", "dress", "pants", "jeans", "shorts",
|
|
|
-# "skirt", "jacket", "coat", "sweater", "hoodie", "top",
|
|
|
-# "blouse", "cardigan", "blazer"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "pattern": PATTERNS,
|
|
|
-# "material": ["cotton", "polyester", "denim", "leather", "silk",
|
|
|
-# "wool", "linen", "blend", "canvas"],
|
|
|
-# "style": STYLES,
|
|
|
-# "fit": FITS,
|
|
|
-# "neckline": ["crew neck", "v-neck", "round neck", "collar",
|
|
|
-# "scoop neck", "boat neck", "turtleneck"],
|
|
|
-# "sleeve_type": ["short sleeve", "long sleeve", "sleeveless",
|
|
|
-# "3/4 sleeve", "cap sleeve"],
|
|
|
-# "closure_type": ["button", "zipper", "pull-on", "snap", "tie", "buckle"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== FOOTWEAR ====================
|
|
|
-# "footwear": {
|
|
|
-# "products": ["shoes", "sneakers", "sandals", "boots", "slippers",
|
|
|
-# "heels", "loafers"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["leather", "synthetic", "canvas", "rubber", "suede", "fabric"],
|
|
|
-# "type": ["sneakers", "sandals", "formal", "boots", "sports", "casual"],
|
|
|
-# "style": STYLES,
|
|
|
-# "closure_type": ["lace-up", "slip-on", "velcro", "zipper", "buckle"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== ACCESSORIES ====================
|
|
|
-# "accessories": {
|
|
|
-# "products": ["watch", "bag", "backpack", "handbag", "wallet", "belt",
|
|
|
-# "sunglasses", "hat", "scarf"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["leather", "fabric", "metal", "plastic", "canvas", "synthetic"],
|
|
|
-# "style": STYLES,
|
|
|
-# "type": ["backpack", "tote", "crossbody", "messenger", "duffel"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== JEWELRY ====================
|
|
|
-# "jewelry": {
|
|
|
-# "products": ["necklace", "ring", "bracelet", "earrings", "pendant", "chain"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["gold", "silver", "platinum", "stainless steel",
|
|
|
-# "plastic", "beads", "leather"],
|
|
|
-# "style": ["modern", "vintage", "minimalist", "statement", "elegant"],
|
|
|
-# "type": ["chain", "band", "solitaire", "hoop", "stud"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== ELECTRONICS ====================
|
|
|
-# "electronics": {
|
|
|
-# "products": ["phone", "smartphone", "tablet", "laptop", "headphones",
|
|
|
-# "camera", "tv", "monitor", "keyboard", "mouse", "speaker",
|
|
|
-# "smartwatch", "charger"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["plastic", "metal", "glass", "aluminum", "rubber"],
|
|
|
-# "style": ["modern", "minimalist", "sleek", "industrial"],
|
|
|
-# "finish": ["matte", "glossy", "metallic", "textured"],
|
|
|
-# "type": ["over-ear", "in-ear", "on-ear", "wireless", "wired"],
|
|
|
-# "brand": BRANDS
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== FURNITURE ====================
|
|
|
-# "furniture": {
|
|
|
-# "products": ["chair", "table", "sofa", "bed", "desk", "shelf",
|
|
|
-# "cabinet", "dresser", "bench", "stool", "bookshelf"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["wood", "metal", "glass", "plastic", "fabric", "leather"],
|
|
|
-# "style": ["modern", "traditional", "industrial", "rustic",
|
|
|
-# "contemporary", "vintage", "minimalist"],
|
|
|
-# "finish": ["natural wood", "painted", "stained", "laminated", "upholstered"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== HOME DECOR ====================
|
|
|
-# "home_decor": {
|
|
|
-# "products": ["painting", "canvas", "wall art", "frame", "vase", "lamp",
|
|
|
-# "mirror", "clock", "sculpture", "poster", "cushion", "rug"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "style": ["modern", "abstract", "traditional", "contemporary",
|
|
|
-# "vintage", "minimalist", "bohemian"],
|
|
|
-# "material": ["canvas", "wood", "metal", "glass", "ceramic", "paper", "fabric"],
|
|
|
-# "finish": ["glossy", "matte", "textured", "framed"],
|
|
|
-# "theme": ["nature", "geometric", "floral", "landscape", "abstract"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== KITCHEN ====================
|
|
|
-# "kitchen": {
|
|
|
-# "products": ["pot", "pan", "knife", "utensil", "plate", "bowl", "cup",
|
|
|
-# "mug", "bottle", "container", "cutting board"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["stainless steel", "aluminum", "ceramic", "glass",
|
|
|
-# "plastic", "wood", "silicone"],
|
|
|
-# "finish": ["non-stick", "stainless", "enameled", "anodized"],
|
|
|
-# "type": ["frypan", "saucepan", "chef knife", "utility", "mixing"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== APPLIANCES ====================
|
|
|
-# "appliances": {
|
|
|
-# "products": ["microwave", "blender", "vacuum", "fan", "toaster",
|
|
|
-# "coffee maker", "iron", "hair dryer"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "type": ["upright", "robot", "handheld", "ceiling", "table", "tower"],
|
|
|
-# "power": ["low", "medium", "high", "variable"],
|
|
|
-# "brand": BRANDS
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== BEAUTY & PERSONAL CARE ====================
|
|
|
-# "beauty": {
|
|
|
-# "products": ["lipstick", "perfume", "lotion", "hair dryer", "makeup",
|
|
|
-# "skincare", "nail polish", "shampoo"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "type": ["eau de parfum", "eau de toilette", "body spray",
|
|
|
-# "body lotion", "face cream"],
|
|
|
-# "finish": ["matte", "glossy", "satin", "shimmer"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== TOYS ====================
|
|
|
-# "toys": {
|
|
|
-# "products": ["doll", "puzzle", "board game", "action figure", "plush toy",
|
|
|
-# "toy car", "lego", "building blocks"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "age_group": AGE_GROUPS,
|
|
|
-# "material": ["plastic", "wood", "fabric", "metal", "foam"],
|
|
|
-# "type": ["educational", "plush", "action", "vehicle", "puzzle", "board game"],
|
|
|
-# "brand": BRANDS
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== SPORTS & OUTDOOR ====================
|
|
|
-# "sports": {
|
|
|
-# "products": ["bicycle", "football", "basketball", "tennis racket",
|
|
|
-# "yoga mat", "helmet", "skateboard", "dumbbells", "ball"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["steel", "aluminum", "carbon fiber", "rubber",
|
|
|
-# "leather", "synthetic", "foam", "composite"],
|
|
|
-# "sport_type": ["football", "basketball", "tennis", "cycling",
|
|
|
-# "yoga", "gym", "outdoor", "fitness"],
|
|
|
-# "type": ["mountain", "road", "hybrid", "bmx", "indoor", "outdoor"],
|
|
|
-# "brand": BRANDS
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== PET SUPPLIES ====================
|
|
|
-# "pet_supplies": {
|
|
|
-# "products": ["pet bed", "pet toy", "leash", "pet bowl", "collar",
|
|
|
-# "pet carrier"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["fabric", "plastic", "metal", "nylon", "leather"],
|
|
|
-# "size": ["small", "medium", "large", "extra large"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== BABY PRODUCTS ====================
|
|
|
-# "baby": {
|
|
|
-# "products": ["stroller", "baby bottle", "diaper", "crib", "high chair",
|
|
|
-# "baby carrier"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": MATERIALS,
|
|
|
-# "type": ["full-size", "umbrella", "jogging", "disposable", "cloth"],
|
|
|
-# "age_group": ["newborn", "baby", "toddler"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== TOOLS & HARDWARE ====================
|
|
|
-# "tools": {
|
|
|
-# "products": ["hammer", "drill", "screwdriver", "wrench", "saw",
|
|
|
-# "pliers", "measuring tape", "level"],
|
|
|
-# "attributes": {
|
|
|
-# "material": ["steel", "aluminum", "plastic", "wood", "rubber",
|
|
|
-# "chrome", "fiberglass"],
|
|
|
-# "type": ["manual", "electric", "cordless", "corded", "pneumatic"],
|
|
|
-# "finish": ["chrome plated", "powder coated", "stainless steel"],
|
|
|
-# "brand": BRANDS
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== BOOKS & MEDIA ====================
|
|
|
-# "books_media": {
|
|
|
-# "products": ["book", "magazine", "dvd", "video game", "cd", "vinyl"],
|
|
|
-# "attributes": {
|
|
|
-# "type": ["paperback", "hardcover", "ebook", "audiobook"],
|
|
|
-# "genre": ["fiction", "non-fiction", "educational", "kids",
|
|
|
-# "action", "adventure", "sports", "rpg"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== AUTOMOTIVE ====================
|
|
|
-# "automotive": {
|
|
|
-# "products": ["car accessory", "tire", "car seat", "steering wheel cover",
|
|
|
-# "floor mat"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["rubber", "plastic", "fabric", "leather", "vinyl"],
|
|
|
-# "type": ["universal", "custom fit"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== OFFICE SUPPLIES ====================
|
|
|
-# "office": {
|
|
|
-# "products": ["pen", "notebook", "folder", "desk organizer", "stapler",
|
|
|
-# "calculator", "paper"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["paper", "plastic", "metal", "cardboard"],
|
|
|
-# "type": ["ruled", "blank", "grid", "dot grid"]
|
|
|
-# }
|
|
|
-# },
|
|
|
-
|
|
|
-# # ==================== GARDEN & OUTDOOR ====================
|
|
|
-# "garden": {
|
|
|
-# "products": ["plant pot", "garden tool", "watering can", "planter",
|
|
|
-# "garden hose", "lawn mower"],
|
|
|
-# "attributes": {
|
|
|
-# "color": COLORS,
|
|
|
-# "material": ["ceramic", "plastic", "metal", "terracotta", "wood"],
|
|
|
-# "type": ["indoor", "outdoor", "hanging", "standing"]
|
|
|
-# }
|
|
|
-# }
|
|
|
-# }
|
|
|
-
|
|
|
-# # Attribute-specific confidence thresholds
|
|
|
-# CONFIDENCE_THRESHOLDS = {
|
|
|
-# "color": 0.20,
|
|
|
-# "pattern": 0.25,
|
|
|
-# "material": 0.30,
|
|
|
-# "style": 0.20,
|
|
|
-# "fit": 0.25,
|
|
|
-# "brand": 0.40,
|
|
|
-# "type": 0.22,
|
|
|
-# "finish": 0.28,
|
|
|
-# "neckline": 0.23,
|
|
|
-# "sleeve_type": 0.23
|
|
|
-# }
|
|
|
-
|
|
|
-# def __init__(self):
|
|
|
-# pass
|
|
|
-
|
|
|
-# @classmethod
|
|
|
-# def _get_device(cls):
|
|
|
-# """Get optimal device."""
|
|
|
-# if cls._device is None:
|
|
|
-# cls._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
|
|
-# logger.info(f"Visual Processing using device: {cls._device}")
|
|
|
-# return cls._device
|
|
|
-
|
|
|
-# @classmethod
|
|
|
-# def _get_clip_model(cls):
|
|
|
-# """Lazy load CLIP model with class-level caching."""
|
|
|
-# if cls._clip_model is None:
|
|
|
-# logger.info("Loading CLIP model (this may take a few minutes on first use)...")
|
|
|
-# cls._clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
|
|
|
-# cls._clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
|
|
|
-
|
|
|
-# device = cls._get_device()
|
|
|
-# cls._clip_model.to(device)
|
|
|
-# cls._clip_model.eval()
|
|
|
-
|
|
|
-# logger.info("✓ CLIP model loaded successfully")
|
|
|
-# return cls._clip_model, cls._clip_processor
|
|
|
-
|
|
|
-# def center_crop(self, image: Image.Image, rel_crop: float = 0.7) -> Image.Image:
|
|
|
-# """
|
|
|
-# Center-crop to focus on the product area if there is too much background.
|
|
|
-
|
|
|
-# Args:
|
|
|
-# image: PIL Image
|
|
|
-# rel_crop: Relative crop size (0.7 = 70% of min dimension)
|
|
|
-# """
|
|
|
-# w, h = image.size
|
|
|
-# side = int(min(w, h) * rel_crop)
|
|
|
-# left = (w - side) // 2
|
|
|
-# top = (h - side) // 2
|
|
|
-# return image.crop((left, top, left + side, top + side))
|
|
|
-
|
|
|
-# def download_image(self, image_url: str, apply_crop: bool = False,
|
|
|
-# max_size: Tuple[int, int] = (1024, 1024)) -> Optional[Image.Image]:
|
|
|
-# """
|
|
|
-# Download image from URL with optional preprocessing.
|
|
|
-
|
|
|
-# Args:
|
|
|
-# image_url: URL of the image
|
|
|
-# apply_crop: Whether to apply center crop
|
|
|
-# max_size: Maximum dimensions for resizing
|
|
|
-# """
|
|
|
-# try:
|
|
|
-# response = requests.get(image_url, timeout=10)
|
|
|
-# response.raise_for_status()
|
|
|
-# image = Image.open(BytesIO(response.content)).convert('RGB')
|
|
|
-
|
|
|
-# # Resize if too large
|
|
|
-# if image.size[0] > max_size[0] or image.size[1] > max_size[1]:
|
|
|
-# image.thumbnail(max_size, Image.Resampling.LANCZOS)
|
|
|
-
|
|
|
-# # Optional center crop
|
|
|
-# if apply_crop:
|
|
|
-# image = self.center_crop(image, rel_crop=0.7)
|
|
|
-
|
|
|
-# return image
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error downloading image from {image_url}: {str(e)}")
|
|
|
-# return None
|
|
|
-
|
|
|
-# def normalize_color(self, word: str) -> str:
|
|
|
-# """
|
|
|
-# Enhanced color normalization with aliases and modifiers.
|
|
|
-
|
|
|
-# Args:
|
|
|
-# word: Color word to normalize
|
|
|
-# """
|
|
|
-# w = word.lower().strip()
|
|
|
-
|
|
|
-# # Remove light/dark modifiers
|
|
|
-# w = w.replace("light ", "").replace("dark ", "")
|
|
|
-# w = w.replace("bright ", "").replace("pale ", "")
|
|
|
-
|
|
|
-# # Alias mapping
|
|
|
-# aliases = {
|
|
|
-# "grey": "gray",
|
|
|
-# "navy": "blue",
|
|
|
-# "navy blue": "blue",
|
|
|
-# "maroon": "red",
|
|
|
-# "crimson": "red",
|
|
|
-# "scarlet": "red",
|
|
|
-# "teal": "green",
|
|
|
-# "turquoise": "blue",
|
|
|
-# "cyan": "blue",
|
|
|
-# "indigo": "blue",
|
|
|
-# "violet": "purple",
|
|
|
-# "lavender": "purple",
|
|
|
-# "magenta": "pink",
|
|
|
-# "off white": "white",
|
|
|
-# "off-white": "white",
|
|
|
-# "cream": "beige",
|
|
|
-# "ivory": "white",
|
|
|
-# "khaki": "beige",
|
|
|
-# "tan": "brown",
|
|
|
-# "bronze": "brown",
|
|
|
-# "gold": "yellow",
|
|
|
-# "silver": "gray",
|
|
|
-# "charcoal": "gray"
|
|
|
-# }
|
|
|
-
|
|
|
-# normalized = aliases.get(w, w)
|
|
|
-
|
|
|
-# # Validate against canonical colors
|
|
|
-# if normalized not in [c.lower() for c in self.COLORS]:
|
|
|
-# # Try first word if it's a compound
|
|
|
-# first_word = normalized.split()[0] if ' ' in normalized else normalized
|
|
|
-# if first_word in [c.lower() for c in self.COLORS]:
|
|
|
-# return first_word
|
|
|
-
|
|
|
-# return normalized
|
|
|
-
|
|
|
-# def extract_dominant_colors(self, image: Image.Image, n_colors: int = 3) -> List[Dict]:
|
|
|
-# """Extract dominant colors using K-means clustering."""
|
|
|
-# try:
|
|
|
-# # Resize for faster processing
|
|
|
-# img_small = image.resize((150, 150))
|
|
|
-# img_array = np.array(img_small)
|
|
|
-# pixels = img_array.reshape(-1, 3)
|
|
|
-
|
|
|
-# # Sample if too many pixels
|
|
|
-# if len(pixels) > 10000:
|
|
|
-# indices = np.random.choice(len(pixels), 10000, replace=False)
|
|
|
-# pixels = pixels[indices]
|
|
|
-
|
|
|
-# # K-means clustering
|
|
|
-# kmeans = KMeans(n_clusters=n_colors, random_state=42, n_init=5, max_iter=100)
|
|
|
-# kmeans.fit(pixels)
|
|
|
-
|
|
|
-# colors = []
|
|
|
-# labels_counts = np.bincount(kmeans.labels_)
|
|
|
-
|
|
|
-# for i, center in enumerate(kmeans.cluster_centers_):
|
|
|
-# rgb = tuple(center.astype(int))
|
|
|
-# color_name = self._get_color_name_simple(rgb)
|
|
|
-# percentage = float(labels_counts[i] / len(kmeans.labels_) * 100)
|
|
|
-
|
|
|
-# colors.append({
|
|
|
-# "name": color_name,
|
|
|
-# "rgb": rgb,
|
|
|
-# "percentage": percentage
|
|
|
-# })
|
|
|
-
|
|
|
-# colors.sort(key=lambda x: x['percentage'], reverse=True)
|
|
|
-# return colors
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error extracting colors: {str(e)}")
|
|
|
-# return []
|
|
|
-
|
|
|
-# def _get_color_name_simple(self, rgb: Tuple[int, int, int]) -> str:
|
|
|
-# """Simple RGB to color name mapping."""
|
|
|
-# r, g, b = rgb
|
|
|
-
|
|
|
-# # Define color ranges
|
|
|
-# colors = {
|
|
|
-# 'black': (r < 50 and g < 50 and b < 50),
|
|
|
-# 'white': (r > 200 and g > 200 and b > 200),
|
|
|
-# 'gray': (abs(r - g) < 30 and abs(g - b) < 30 and abs(r - b) < 30 and 50 <= r <= 200),
|
|
|
-# 'red': (r > 150 and g < 100 and b < 100),
|
|
|
-# 'green': (g > 150 and r < 100 and b < 100),
|
|
|
-# 'blue': (b > 150 and r < 100 and g < 100),
|
|
|
-# 'yellow': (r > 200 and g > 200 and b < 100),
|
|
|
-# 'orange': (r > 200 and 100 < g < 200 and b < 100),
|
|
|
-# 'purple': (r > 100 and b > 100 and g < 100),
|
|
|
-# 'pink': (r > 200 and 100 < g < 200 and 100 < b < 200),
|
|
|
-# 'brown': (50 < r < 150 and 30 < g < 100 and b < 80),
|
|
|
-# 'beige': (150 < r < 220 and 140 < g < 200 and 100 < b < 180),
|
|
|
-# }
|
|
|
-
|
|
|
-# for color_name, condition in colors.items():
|
|
|
-# if condition:
|
|
|
-# return color_name
|
|
|
-
|
|
|
-# # Fallback based on dominant channel
|
|
|
-# if r > g and r > b:
|
|
|
-# return 'red'
|
|
|
-# elif g > r and g > b:
|
|
|
-# return 'green'
|
|
|
-# elif b > r and b > g:
|
|
|
-# return 'blue'
|
|
|
-# else:
|
|
|
-# return 'gray'
|
|
|
-
|
|
|
-# def classify_with_clip(
|
|
|
-# self,
|
|
|
-# image: Image.Image,
|
|
|
-# candidates: List[str],
|
|
|
-# attribute_name: str,
|
|
|
-# confidence_threshold: Optional[float] = None
|
|
|
-# ) -> Dict:
|
|
|
-# """
|
|
|
-# Use CLIP to classify image against candidate labels.
|
|
|
-
|
|
|
-# Args:
|
|
|
-# image: PIL Image
|
|
|
-# candidates: List of text labels to classify against
|
|
|
-# attribute_name: Name of the attribute being classified
|
|
|
-# confidence_threshold: Override default threshold
|
|
|
-# """
|
|
|
-# try:
|
|
|
-# model, processor = self._get_clip_model()
|
|
|
-# device = self._get_device()
|
|
|
-
|
|
|
-# # Use attribute-specific threshold if not provided
|
|
|
-# if confidence_threshold is None:
|
|
|
-# confidence_threshold = self.CONFIDENCE_THRESHOLDS.get(attribute_name, 0.20)
|
|
|
-
|
|
|
-# # Prepare inputs
|
|
|
-# inputs = processor(
|
|
|
-# text=candidates,
|
|
|
-# images=image,
|
|
|
-# return_tensors="pt",
|
|
|
-# padding=True
|
|
|
-# )
|
|
|
-
|
|
|
-# # Move to device
|
|
|
-# inputs = {k: v.to(device) for k, v in inputs.items()}
|
|
|
-
|
|
|
-# # Get predictions
|
|
|
-# with torch.no_grad():
|
|
|
-# outputs = model(**inputs)
|
|
|
-# logits_per_image = outputs.logits_per_image
|
|
|
-# probs = logits_per_image.softmax(dim=1).cpu()
|
|
|
-
|
|
|
-# # Get top predictions
|
|
|
-# top_k = min(3, len(candidates))
|
|
|
-# top_probs, top_indices = torch.topk(probs[0], k=top_k)
|
|
|
-
|
|
|
-# results = []
|
|
|
-# for prob, idx in zip(top_probs, top_indices):
|
|
|
-# if prob.item() > confidence_threshold:
|
|
|
-# value = candidates[idx.item()]
|
|
|
-# # Apply color normalization if color attribute
|
|
|
-# if attribute_name == "color":
|
|
|
-# value = self.normalize_color(value)
|
|
|
-# results.append({
|
|
|
-# "value": value,
|
|
|
-# "confidence": float(prob.item())
|
|
|
-# })
|
|
|
-
|
|
|
-# return {
|
|
|
-# "attribute": attribute_name,
|
|
|
-# "predictions": results
|
|
|
-# }
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error in CLIP classification for {attribute_name}: {str(e)}")
|
|
|
-# return {"attribute": attribute_name, "predictions": []}
|
|
|
-
|
|
|
-# def detect_category_hierarchical(self, image: Image.Image) -> Tuple[str, str, float]:
|
|
|
-# """
|
|
|
-# Two-stage hierarchical product detection:
|
|
|
-# 1. Detect broad category
|
|
|
-# 2. Detect specific product within that category
|
|
|
-
|
|
|
-# Returns:
|
|
|
-# (category, product_type, confidence)
|
|
|
-# """
|
|
|
-# # Stage 1: Detect broad category
|
|
|
-# category_names = list(self.CATEGORY_ATTRIBUTES.keys())
|
|
|
-# category_labels = [f"a photo of {cat.replace('_', ' ')}" for cat in category_names]
|
|
|
-
|
|
|
-# category_result = self.classify_with_clip(
|
|
|
-# image, category_labels, "category_detection", confidence_threshold=0.15
|
|
|
-# )
|
|
|
-
|
|
|
-# if not category_result["predictions"]:
|
|
|
-# return "unknown", "unknown", 0.0
|
|
|
-
|
|
|
-# # Extract category
|
|
|
-# best_category_match = category_result["predictions"][0]
|
|
|
-# detected_category = category_names[category_labels.index(best_category_match["value"])]
|
|
|
-# category_confidence = best_category_match["confidence"]
|
|
|
-
|
|
|
-# # Stage 2: Detect specific product within category
|
|
|
-# products_in_category = self.CATEGORY_ATTRIBUTES[detected_category]["products"]
|
|
|
-# product_labels = [f"a photo of a {p}" for p in products_in_category]
|
|
|
-
|
|
|
-# product_result = self.classify_with_clip(
|
|
|
-# image, product_labels, "product_detection", confidence_threshold=0.15
|
|
|
-# )
|
|
|
-
|
|
|
-# if product_result["predictions"]:
|
|
|
-# best_product = product_result["predictions"][0]
|
|
|
-# product_type = products_in_category[product_labels.index(best_product["value"])]
|
|
|
-# product_confidence = best_product["confidence"]
|
|
|
-
|
|
|
-# # Combined confidence (geometric mean for balance)
|
|
|
-# combined_confidence = (category_confidence * product_confidence) ** 0.5
|
|
|
-
|
|
|
-# logger.info(f"Detected: {detected_category} → {product_type} (confidence: {combined_confidence:.3f})")
|
|
|
-# return detected_category, product_type, combined_confidence
|
|
|
-
|
|
|
-# return detected_category, "unknown", category_confidence * 0.5
|
|
|
-
|
|
|
-# def detect_category_flat(self, image: Image.Image) -> Tuple[str, str, float]:
|
|
|
-# """
|
|
|
-# Single-stage flat product detection across all categories.
|
|
|
-# Faster but potentially less accurate.
|
|
|
-
|
|
|
-# Returns:
|
|
|
-# (category, product_type, confidence)
|
|
|
-# """
|
|
|
-# # Collect all products with their categories
|
|
|
-# all_products = []
|
|
|
-# product_to_category = {}
|
|
|
-
|
|
|
-# for category, data in self.CATEGORY_ATTRIBUTES.items():
|
|
|
-# for product in data["products"]:
|
|
|
-# label = f"a photo of a {product}"
|
|
|
-# all_products.append(label)
|
|
|
-# product_to_category[label] = category
|
|
|
-
|
|
|
-# # Classify
|
|
|
-# result = self.classify_with_clip(
|
|
|
-# image, all_products, "product_detection", confidence_threshold=0.15
|
|
|
-# )
|
|
|
-
|
|
|
-# if result["predictions"]:
|
|
|
-# best_match = result["predictions"][0]
|
|
|
-# product_label = best_match["value"]
|
|
|
-# category = product_to_category[product_label]
|
|
|
-# product_type = product_label.replace("a photo of a ", "")
|
|
|
-# confidence = best_match["confidence"]
|
|
|
-
|
|
|
-# logger.info(f"Detected: {category} → {product_type} (confidence: {confidence:.3f})")
|
|
|
-# return category, product_type, confidence
|
|
|
-
|
|
|
-# return "unknown", "unknown", 0.0
|
|
|
-
|
|
|
-# def process_image(
|
|
|
-# self,
|
|
|
-# image_url: str,
|
|
|
-# product_type_hint: Optional[str] = None,
|
|
|
-# apply_crop: bool = False,
|
|
|
-# detection_mode: str = "hierarchical"
|
|
|
-# ) -> Dict:
|
|
|
-# """
|
|
|
-# Main method to process image and extract visual attributes.
|
|
|
-
|
|
|
-# Args:
|
|
|
-# image_url: URL of the product image
|
|
|
-# product_type_hint: Optional hint about product type
|
|
|
-# apply_crop: Whether to apply center crop for better focus
|
|
|
-# detection_mode: "hierarchical" (slower, more accurate) or "flat" (faster)
|
|
|
-# """
|
|
|
-# import time
|
|
|
-# start_time = time.time()
|
|
|
-
|
|
|
-# try:
|
|
|
-# # Download image
|
|
|
-# image = self.download_image(image_url, apply_crop=apply_crop)
|
|
|
-# if image is None:
|
|
|
-# return {
|
|
|
-# "visual_attributes": {},
|
|
|
-# "error": "Failed to download image"
|
|
|
-# }
|
|
|
-
|
|
|
-# visual_attributes = {}
|
|
|
-# detailed_predictions = {}
|
|
|
-
|
|
|
-# # Step 1: Detect product category and type
|
|
|
-# if detection_mode == "hierarchical":
|
|
|
-# detected_category, detected_product_type, category_confidence = \
|
|
|
-# self.detect_category_hierarchical(image)
|
|
|
-# else:
|
|
|
-# detected_category, detected_product_type, category_confidence = \
|
|
|
-# self.detect_category_flat(image)
|
|
|
-
|
|
|
-# # If confidence is too low, return minimal info
|
|
|
-# if category_confidence < 0.12:
|
|
|
-# logger.warning(f"Low confidence ({category_confidence:.3f}). Returning basic attributes only.")
|
|
|
-# colors = self.extract_dominant_colors(image, n_colors=3)
|
|
|
-# if colors:
|
|
|
-# visual_attributes["primary_color"] = colors[0]["name"]
|
|
|
-# visual_attributes["color_palette"] = [c["name"] for c in colors]
|
|
|
-
|
|
|
-# return {
|
|
|
-# "visual_attributes": visual_attributes,
|
|
|
-# "category_confidence": category_confidence,
|
|
|
-# "processing_time": round(time.time() - start_time, 2),
|
|
|
-# "warning": "Low confidence detection"
|
|
|
-# }
|
|
|
-
|
|
|
-# # Add detected information
|
|
|
-# visual_attributes["product_type"] = detected_product_type
|
|
|
-# visual_attributes["category"] = detected_category
|
|
|
-# visual_attributes["detection_confidence"] = round(category_confidence, 3)
|
|
|
-
|
|
|
-# # Step 2: Extract universal color attribute
|
|
|
-# colors = self.extract_dominant_colors(image, n_colors=3)
|
|
|
-# if colors:
|
|
|
-# visual_attributes["primary_color"] = colors[0]["name"]
|
|
|
-# visual_attributes["color_palette"] = [c["name"] for c in colors]
|
|
|
-# visual_attributes["color_distribution"] = [
|
|
|
-# {"name": c["name"], "percentage": round(c["percentage"], 1)}
|
|
|
-# for c in colors
|
|
|
-# ]
|
|
|
-
|
|
|
-# # Step 3: Extract category-specific attributes
|
|
|
-# if detected_category in self.CATEGORY_ATTRIBUTES:
|
|
|
-# category_config = self.CATEGORY_ATTRIBUTES[detected_category]
|
|
|
-
|
|
|
-# for attr_name, attr_values in category_config["attributes"].items():
|
|
|
-# # Skip color since we already extracted it
|
|
|
-# if attr_name == "color":
|
|
|
-# continue
|
|
|
-
|
|
|
-# # Get attribute-specific threshold
|
|
|
-# threshold = self.CONFIDENCE_THRESHOLDS.get(attr_name, 0.20)
|
|
|
-
|
|
|
-# # Classify
|
|
|
-# result = self.classify_with_clip(
|
|
|
-# image, attr_values, attr_name, confidence_threshold=threshold
|
|
|
-# )
|
|
|
-
|
|
|
-# detailed_predictions[attr_name] = result
|
|
|
-
|
|
|
-# # Only add if confidence is reasonable
|
|
|
-# if result["predictions"]:
|
|
|
-# best_prediction = result["predictions"][0]
|
|
|
-# if best_prediction["confidence"] > threshold:
|
|
|
-# visual_attributes[attr_name] = best_prediction["value"]
|
|
|
-
|
|
|
-# processing_time = time.time() - start_time
|
|
|
-
|
|
|
-# return {
|
|
|
-# "visual_attributes": visual_attributes,
|
|
|
-# "detailed_predictions": detailed_predictions,
|
|
|
-# "detection_confidence": round(category_confidence, 3),
|
|
|
-# "processing_time": round(processing_time, 2),
|
|
|
-# "metadata": {
|
|
|
-# "detection_mode": detection_mode,
|
|
|
-# "crop_applied": apply_crop,
|
|
|
-# "image_size": image.size
|
|
|
-# }
|
|
|
-# }
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.error(f"Error processing image: {str(e)}")
|
|
|
-# import traceback
|
|
|
-# traceback.print_exc()
|
|
|
-# return {
|
|
|
-# "visual_attributes": {},
|
|
|
-# "error": str(e),
|
|
|
-# "processing_time": round(time.time() - start_time, 2)
|
|
|
-# }
|
|
|
-
|
|
|
-# def batch_process_images(
|
|
|
-# self,
|
|
|
-# image_urls: List[str],
|
|
|
-# detection_mode: str = "flat"
|
|
|
-# ) -> List[Dict]:
|
|
|
-# """
|
|
|
-# Process multiple images in batch.
|
|
|
-
|
|
|
-# Args:
|
|
|
-# image_urls: List of image URLs
|
|
|
-# detection_mode: Detection mode to use
|
|
|
-# """
|
|
|
-# results = []
|
|
|
-# for i, url in enumerate(image_urls):
|
|
|
-# logger.info(f"Processing image {i+1}/{len(image_urls)}: {url}")
|
|
|
-# result = self.process_image(url, detection_mode=detection_mode)
|
|
|
-# results.append(result)
|
|
|
-# return results
|
|
|
-
|
|
|
-# @classmethod
|
|
|
-# def cleanup_models(cls):
|
|
|
-# """Free up memory by unloading models."""
|
|
|
-# if cls._clip_model is not None:
|
|
|
-# del cls._clip_model
|
|
|
-# del cls._clip_processor
|
|
|
-# cls._clip_model = None
|
|
|
-# cls._clip_processor = None
|
|
|
-
|
|
|
-# if torch.cuda.is_available():
|
|
|
-# torch.cuda.empty_cache()
|
|
|
-
|
|
|
-# logger.info("Models unloaded and memory freed")
|
|
|
-
|
|
|
-# def get_supported_categories(self) -> List[str]:
|
|
|
-# """Get list of all supported product categories."""
|
|
|
-# return list(self.CATEGORY_ATTRIBUTES.keys())
|
|
|
-
|
|
|
-# def get_category_products(self, category: str) -> List[str]:
|
|
|
-# """Get list of products in a specific category."""
|
|
|
-# return self.CATEGORY_ATTRIBUTES.get(category, {}).get("products", [])
|
|
|
-
|
|
|
-# def get_category_attributes(self, category: str) -> Dict[str, List[str]]:
|
|
|
-# """Get attribute schema for a specific category."""
|
|
|
-# return self.CATEGORY_ATTRIBUTES.get(category, {}).get("attributes", {})
|
|
|
-
|
|
|
-# def get_statistics(self) -> Dict:
|
|
|
-# """Get statistics about the taxonomy."""
|
|
|
-# total_products = sum(
|
|
|
-# len(data["products"])
|
|
|
-# for data in self.CATEGORY_ATTRIBUTES.values()
|
|
|
-# )
|
|
|
-# total_attributes = sum(
|
|
|
-# len(data["attributes"])
|
|
|
-# for data in self.CATEGORY_ATTRIBUTES.values()
|
|
|
-# )
|
|
|
-
|
|
|
-# return {
|
|
|
-# "total_categories": len(self.CATEGORY_ATTRIBUTES),
|
|
|
-# "total_products": total_products,
|
|
|
-# "total_unique_attributes": len(set(
|
|
|
-# attr
|
|
|
-# for data in self.CATEGORY_ATTRIBUTES.values()
|
|
|
-# for attr in data["attributes"].keys()
|
|
|
-# )),
|
|
|
-# "categories": list(self.CATEGORY_ATTRIBUTES.keys())
|
|
|
-# }
|
|
|
-
|
|
|
-
|
|
|
-# # ==================== USAGE EXAMPLES ====================
|
|
|
-
|
|
|
-# def example_basic_usage():
|
|
|
-# """Basic usage example."""
|
|
|
-# print("=== Basic Usage Example ===\n")
|
|
|
-
|
|
|
-# # Initialize service
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# # Process single image (hierarchical mode - more accurate)
|
|
|
-# result = service.process_image(
|
|
|
-# "https://example.com/product.jpg",
|
|
|
-# detection_mode="hierarchical"
|
|
|
-# )
|
|
|
-
|
|
|
-# print("Product Type:", result["visual_attributes"].get("product_type"))
|
|
|
-# print("Category:", result["visual_attributes"].get("category"))
|
|
|
-# print("Primary Color:", result["visual_attributes"].get("primary_color"))
|
|
|
-# print("Detection Confidence:", result.get("detection_confidence"))
|
|
|
-# print("Processing Time:", result["processing_time"], "seconds")
|
|
|
-# print("\nAll Attributes:")
|
|
|
-# for key, value in result["visual_attributes"].items():
|
|
|
-# print(f" {key}: {value}")
|
|
|
-
|
|
|
-
|
|
|
-# def example_fast_mode():
|
|
|
-# """Fast processing mode example."""
|
|
|
-# print("\n=== Fast Mode Example ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# # Fast mode (flat detection)
|
|
|
-# result = service.process_image(
|
|
|
-# "https://example.com/product.jpg",
|
|
|
-# detection_mode="flat" # Faster, single-stage detection
|
|
|
-# )
|
|
|
-
|
|
|
-# print("Processing Time:", result["processing_time"], "seconds")
|
|
|
-# print("Detected:", result["visual_attributes"])
|
|
|
-
|
|
|
-
|
|
|
-# def example_with_cropping():
|
|
|
-# """Example with center cropping for busy backgrounds."""
|
|
|
-# print("\n=== With Center Cropping ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# # Apply center crop to focus on product
|
|
|
-# result = service.process_image(
|
|
|
-# "https://example.com/product-with-background.jpg",
|
|
|
-# apply_crop=True, # Enable center cropping
|
|
|
-# detection_mode="hierarchical"
|
|
|
-# )
|
|
|
-
|
|
|
-# print("Crop Applied:", result["metadata"]["crop_applied"])
|
|
|
-# print("Detected:", result["visual_attributes"])
|
|
|
-
|
|
|
-
|
|
|
-# def example_batch_processing():
|
|
|
-# """Batch processing example."""
|
|
|
-# print("\n=== Batch Processing ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# image_urls = [
|
|
|
-# "https://example.com/product1.jpg",
|
|
|
-# "https://example.com/product2.jpg",
|
|
|
-# "https://example.com/product3.jpg"
|
|
|
-# ]
|
|
|
-
|
|
|
-# results = service.batch_process_images(image_urls, detection_mode="flat")
|
|
|
-
|
|
|
-# for i, result in enumerate(results):
|
|
|
-# print(f"\nProduct {i+1}:")
|
|
|
-# print(f" Type: {result['visual_attributes'].get('product_type')}")
|
|
|
-# print(f" Category: {result['visual_attributes'].get('category')}")
|
|
|
-# print(f" Time: {result['processing_time']}s")
|
|
|
-
|
|
|
-
|
|
|
-# def example_category_info():
|
|
|
-# """Get information about supported categories."""
|
|
|
-# print("\n=== Category Information ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# # Get statistics
|
|
|
-# stats = service.get_statistics()
|
|
|
-# print("Statistics:")
|
|
|
-# print(f" Total Categories: {stats['total_categories']}")
|
|
|
-# print(f" Total Products: {stats['total_products']}")
|
|
|
-# print(f" Unique Attributes: {stats['total_unique_attributes']}")
|
|
|
-
|
|
|
-# # Get all categories
|
|
|
-# categories = service.get_supported_categories()
|
|
|
-# print(f"\nSupported Categories ({len(categories)}):")
|
|
|
-# for cat in categories:
|
|
|
-# products = service.get_category_products(cat)
|
|
|
-# print(f" {cat}: {len(products)} products")
|
|
|
-
|
|
|
-# # Get attributes for a specific category
|
|
|
-# print("\nClothing Category Attributes:")
|
|
|
-# clothing_attrs = service.get_category_attributes("clothing")
|
|
|
-# for attr, values in clothing_attrs.items():
|
|
|
-# print(f" {attr}: {len(values)} options")
|
|
|
-
|
|
|
-
|
|
|
-# def example_detailed_predictions():
|
|
|
-# """Example showing detailed predictions with confidence scores."""
|
|
|
-# print("\n=== Detailed Predictions ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# result = service.process_image(
|
|
|
-# "https://example.com/product.jpg",
|
|
|
-# detection_mode="hierarchical"
|
|
|
-# )
|
|
|
-
|
|
|
-# print("Visual Attributes (Best Predictions):")
|
|
|
-# for key, value in result["visual_attributes"].items():
|
|
|
-# print(f" {key}: {value}")
|
|
|
-
|
|
|
-# print("\nDetailed Predictions (Top 3 for each attribute):")
|
|
|
-# for attr_name, predictions in result.get("detailed_predictions", {}).items():
|
|
|
-# print(f"\n {attr_name}:")
|
|
|
-# for pred in predictions.get("predictions", []):
|
|
|
-# print(f" - {pred['value']}: {pred['confidence']:.3f}")
|
|
|
-
|
|
|
-
|
|
|
-# def example_color_distribution():
|
|
|
-# """Example showing color palette extraction."""
|
|
|
-# print("\n=== Color Distribution ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# result = service.process_image("https://example.com/product.jpg")
|
|
|
-
|
|
|
-# print("Primary Color:", result["visual_attributes"].get("primary_color"))
|
|
|
-# print("\nColor Palette:")
|
|
|
-# for color in result["visual_attributes"].get("color_palette", []):
|
|
|
-# print(f" - {color}")
|
|
|
-
|
|
|
-# print("\nColor Distribution:")
|
|
|
-# for color_info in result["visual_attributes"].get("color_distribution", []):
|
|
|
-# print(f" {color_info['name']}: {color_info['percentage']}%")
|
|
|
-
|
|
|
-
|
|
|
-# def example_error_handling():
|
|
|
-# """Example showing error handling."""
|
|
|
-# print("\n=== Error Handling ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# # Invalid URL
|
|
|
-# result = service.process_image("https://invalid-url.com/nonexistent.jpg")
|
|
|
-
|
|
|
-# if "error" in result:
|
|
|
-# print("Error occurred:", result["error"])
|
|
|
-# else:
|
|
|
-# print("Processing successful")
|
|
|
-
|
|
|
-# # Low confidence warning
|
|
|
-# result = service.process_image("https://example.com/ambiguous-product.jpg")
|
|
|
-
|
|
|
-# if "warning" in result:
|
|
|
-# print("Warning:", result["warning"])
|
|
|
-# print("Confidence:", result.get("category_confidence"))
|
|
|
-
|
|
|
-
|
|
|
-# def example_cleanup():
|
|
|
-# """Example showing model cleanup."""
|
|
|
-# print("\n=== Model Cleanup ===\n")
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# # Process some images
|
|
|
-# result = service.process_image("https://example.com/product.jpg")
|
|
|
-# print("Processed successfully")
|
|
|
-
|
|
|
-# # Clean up models when done (frees memory)
|
|
|
-# VisualProcessingService.cleanup_models()
|
|
|
-# print("Models cleaned up and memory freed")
|
|
|
-
|
|
|
-
|
|
|
-# # ==================== PRODUCTION USAGE ====================
|
|
|
-
|
|
|
-# def production_example():
|
|
|
-# """
|
|
|
-# Production-ready example with proper error handling and logging.
|
|
|
-# """
|
|
|
-# import logging
|
|
|
-
|
|
|
-# # Setup logging
|
|
|
-# logging.basicConfig(
|
|
|
-# level=logging.INFO,
|
|
|
-# format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
|
|
-# )
|
|
|
-
|
|
|
-# service = VisualProcessingService()
|
|
|
-
|
|
|
-# def process_product_image(image_url: str, product_id: str) -> Dict:
|
|
|
-# """
|
|
|
-# Process a product image with full error handling.
|
|
|
-# """
|
|
|
-# try:
|
|
|
-# # Process with hierarchical mode for best accuracy
|
|
|
-# result = service.process_image(
|
|
|
-# image_url,
|
|
|
-# detection_mode="hierarchical",
|
|
|
-# apply_crop=False # Set True if images have busy backgrounds
|
|
|
-# )
|
|
|
-
|
|
|
-# # Check for errors
|
|
|
-# if "error" in result:
|
|
|
-# logger.error(f"Failed to process {product_id}: {result['error']}")
|
|
|
-# return {
|
|
|
-# "product_id": product_id,
|
|
|
-# "status": "error",
|
|
|
-# "error": result["error"]
|
|
|
-# }
|
|
|
-
|
|
|
-# # Check confidence
|
|
|
-# confidence = result.get("detection_confidence", 0)
|
|
|
-# if confidence < 0.15:
|
|
|
-# logger.warning(f"Low confidence for {product_id}: {confidence}")
|
|
|
-# return {
|
|
|
-# "product_id": product_id,
|
|
|
-# "status": "low_confidence",
|
|
|
-# "confidence": confidence,
|
|
|
-# "partial_attributes": result["visual_attributes"]
|
|
|
-# }
|
|
|
-
|
|
|
-# # Success
|
|
|
-# return {
|
|
|
-# "product_id": product_id,
|
|
|
-# "status": "success",
|
|
|
-# "attributes": result["visual_attributes"],
|
|
|
-# "confidence": confidence,
|
|
|
-# "processing_time": result["processing_time"]
|
|
|
-# }
|
|
|
-
|
|
|
-# except Exception as e:
|
|
|
-# logger.exception(f"Unexpected error processing {product_id}")
|
|
|
-# return {
|
|
|
-# "product_id": product_id,
|
|
|
-# "status": "exception",
|
|
|
-# "error": str(e)
|
|
|
-# }
|
|
|
-
|
|
|
-# # Process products
|
|
|
-# products = [
|
|
|
-# {"id": "PROD001", "image_url": "https://example.com/tshirt.jpg"},
|
|
|
-# {"id": "PROD002", "image_url": "https://example.com/laptop.jpg"},
|
|
|
-# {"id": "PROD003", "image_url": "https://example.com/chair.jpg"}
|
|
|
-# ]
|
|
|
-
|
|
|
-# results = []
|
|
|
-# for product in products:
|
|
|
-# result = process_product_image(product["image_url"], product["id"])
|
|
|
-# results.append(result)
|
|
|
-
|
|
|
-# # Print summary
|
|
|
-# if result["status"] == "success":
|
|
|
-# attrs = result["attributes"]
|
|
|
-# print(f"\n✓ {product['id']} ({result['processing_time']}s):")
|
|
|
-# print(f" Type: {attrs.get('product_type')}")
|
|
|
-# print(f" Category: {attrs.get('category')}")
|
|
|
-# print(f" Color: {attrs.get('primary_color')}")
|
|
|
-# else:
|
|
|
-# print(f"\n✗ {product['id']}: {result['status']}")
|
|
|
-
|
|
|
-# return results
|
|
|
-
|
|
|
-
|
|
|
-# # ==================== MAIN ====================
|
|
|
-
|
|
|
-# if __name__ == "__main__":
|
|
|
-# # Run examples
|
|
|
-# print("Enhanced Visual Processing Service")
|
|
|
-# print("=" * 60)
|
|
|
-
|
|
|
-# # Show statistics
|
|
|
-# service = VisualProcessingService()
|
|
|
-# stats = service.get_statistics()
|
|
|
-# print(f"\nTaxonomy Coverage:")
|
|
|
-# print(f" Categories: {stats['total_categories']}")
|
|
|
-# print(f" Products: {stats['total_products']}")
|
|
|
-# print(f" Attributes: {stats['total_unique_attributes']}")
|
|
|
-
|
|
|
-# print("\n" + "=" * 60)
|
|
|
-# print("Run individual examples by calling the example functions:")
|
|
|
-# print(" - example_basic_usage()")
|
|
|
-# print(" - example_fast_mode()")
|
|
|
-# print(" - example_with_cropping()")
|
|
|
-# print(" - example_batch_processing()")
|
|
|
-# print(" - example_category_info()")
|
|
|
-# print(" - example_detailed_predictions()")
|
|
|
-# print(" - example_color_distribution()")
|
|
|
-# print(" - production_example()")
|
|
|
-# print("=" * 60)
|
