--- license: apache-2.0 language: - en metrics: - recall base_model: - Ultralytics/YOLOv8 pipeline_tag: object-detection tags: - object_detection - computer-vision - yolo - brand-detection - logo-detection datasets: - haydarkadioglu/brand-eye-dataset --- # 🔍 Brand Eye - YOLO Brand Detection Model A powerful YOLO-based object detection model specifically trained for brand and logo recognition tasks. ## 🌟 Overview Brand Eye is a state-of-the-art computer vision model that can detect and classify various brands and logos in images. Built on the YOLO (You Only Look Once) architecture, it provides fast and accurate real-time brand detection capabilities. ## 📊 Model Performance - **Training Epochs**: 50 - **Best mAP@0.5**: 0.825+ (See training results) - **Best mAP@0.5:0.95**: 0.494+ (See training results) - **Architecture**: YOLOv5/YOLOv8 Custom - **Input Size**: 640x640 - **Model Size**: ~14MB (optimized) ### 📈 Training Metrics ![Training Metrics](images/metrics.png) ### 🎯 Model Accuracy ![Confusion Matrix](images/confusion_matrix_normalized.png) ### 📋 Validation Examples | Ground Truth Labels | Model Predictions | |:-------------------:|:-----------------:| | ![Labels](images/val_batch0_labels.jpg) | ![Predictions](images/val_batch0_pred.jpg) | | *Ground truth annotations* | *Model predictions with confidence scores* | ## 🎬 Demo Results See the model in action! The images above show: - **Training Metrics**: Comprehensive performance charts showing loss curves, precision, recall, and mAP scores over 50 epochs - **Confusion Matrix**: Normalized confusion matrix displaying model accuracy across different brand classes - **Validation Examples**: Side-by-side comparison of ground truth labels vs. model predictions on validation data The model demonstrates excellent performance with: - ✅ High precision in brand detection - ✅ Strong recall across different brand categories - ✅ Accurate bounding box predictions - ✅ Reliable confidence scoring ## 🚀 Quick Start ### Installation ```bash pip install ultralytics huggingface_hub torch torchvision opencv-python pillow ``` ### Download Model from Hugging Face ```python from huggingface_hub import hf_hub_download from ultralytics import YOLO # Download the trained model model_path = hf_hub_download( repo_id="haydarkadioglu/brand-eye", filename="brandeye.pt" ) # Load the model model = YOLO(model_path) ``` ### Basic Usage #### Single Image Detection ```python import cv2 from PIL import Image def detect_brands(image_path, conf_threshold=0.25): """ Detect brands in a single image Args: image_path (str): Path to the image file conf_threshold (float): Confidence threshold (0.0-1.0) Returns: results: Detection results with bounding boxes and labels """ results = model(image_path, conf=conf_threshold) # Display results results[0].show() # Get detection details boxes = results[0].boxes if boxes is not None: print(f"Found {len(boxes)} brand detections:") for box in boxes: conf = box.conf[0].item() cls = int(box.cls[0].item()) class_name = model.names[cls] print(f" - {class_name}: {conf:.3f} confidence") return results # Example usage results = detect_brands("path/to/your/image.jpg") ``` #### Batch Processing ```python import os from pathlib import Path def process_folder(input_folder, output_folder="results", conf=0.25): """ Process all images in a folder Args: input_folder (str): Path to folder containing images output_folder (str): Path to save results conf (float): Confidence threshold """ input_path = Path(input_folder) output_path = Path(output_folder) output_path.mkdir(exist_ok=True) # Supported image formats image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp'] for img_file in input_path.iterdir(): if img_file.suffix.lower() in image_extensions: print(f"Processing {img_file.name}...") # Run detection results = model(str(img_file), conf=conf) # Save annotated image save_path = output_path / f"detected_{img_file.name}" results[0].save(str(save_path)) # Print summary boxes = results[0].boxes if boxes is not None: print(f" ✅ Found {len(boxes)} brands") else: print(f" ❌ No brands detected") # Example usage process_folder("input_images/", "detection_results/") ``` #### Real-time Detection (Webcam) ```python import cv2 def real_time_detection(): """ Real-time brand detection using webcam """ cap = cv2.VideoCapture(0) # Use 0 for default camera while True: ret, frame = cap.read() if not ret: break # Run detection results = model(frame, conf=0.3) # Draw results on frame annotated_frame = results[0].plot() # Display frame cv2.imshow('Brand Detection', annotated_frame) # Exit on 'q' press if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows() # Run real-time detection # real_time_detection() ``` ## 📁 Project Structure ``` brand-eye/ ├── README.md # This file ├── visualize.ipynb # Training results visualization ├── brandeye.pt # Trained model weights ├── model/ │ ├── train/ │ │ ├── results.csv # Training metrics │ │ ├── weights/ │ │ │ └── last.pt # Final model checkpoint │ │ └── *.png # Training plots │ └── val/ │ ├── predictions.json # Validation predictions │ └── *.png # Validation visualizations ├── confusion_matrix_normalized.png # Model confusion matrix └── val_batch*_*.jpg # Validation batch examples ``` ## 🎯 Use Cases - **Brand Monitoring**: Track brand presence in social media images - **Market Research**: Analyze brand visibility in retail environments - **Advertising Analysis**: Measure brand exposure in marketing materials - **Quality Control**: Verify proper brand logo placement - **Content Moderation**: Detect unauthorized brand usage ## 🔧 Advanced Usage ### Custom Confidence Thresholds ```python # High precision (fewer false positives) results_high_conf = model("image.jpg", conf=0.7) # High recall (catch more brands, may include false positives) results_low_conf = model("image.jpg", conf=0.1) ``` ### Export to Different Formats ```python # Export detections to JSON import json def export_detections(image_path, output_json): results = model(image_path) detections = [] boxes = results[0].boxes if boxes is not None: for box in boxes: detection = { "class": model.names[int(box.cls[0])], "confidence": float(box.conf[0]), "bbox": box.xyxy[0].tolist() # [x1, y1, x2, y2] } detections.append(detection) with open(output_json, 'w') as f: json.dump(detections, f, indent=2) export_detections("image.jpg", "detections.json") ``` ## 🤝 Contributing 1. Fork the repository 2. Create a feature branch (`git checkout -b feature/amazing-feature`) 3. Commit your changes (`git commit -m 'Add amazing feature'`) 4. Push to the branch (`git push origin feature/amazing-feature`) 5. Open a Pull Request ## 📄 License This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. ## 📞 Contact - **Project**: [GitHub Repository](https://github.com/haydarkadioglu/brand-eye) - **Model**: [Hugging Face Model](https://huggingface.co/haydarkadioglu/brand-eye) - **Issues**: [GitHub Issues](https://github.com/haydarkadioglu/brand-eye/issues) --- **Made with ❤️ for brand detection**