Add application file

#jewelry_recommender_full.py

@@ -0,0 +1,446 @@
+# config.py
+import os
+import torch
+import torchvision.transforms as transforms
+
+class Config:
+    """Configuration class for the Jewelry Recommender System."""
+    
+    # Model settings
+    VECTOR_DIMENSION = 1280
+    INDEX_PATH = "rootdir/trained_models/jewelry_index.idx"
+    METADATA_PATH = "rootdir/trained_models/jewelry_metadata.pkl"
+    
+    # Hardware settings
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # Image processing settings
+    IMAGE_SIZE = (640, 640)
+    NORMALIZATION_MEAN = [0.485, 0.456, 0.406]
+    NORMALIZATION_STD = [0.229, 0.224, 0.225]
+    
+    # Recommendation settings
+    DEFAULT_NUM_RECOMMENDATIONS = 5
+    MAX_RECOMMENDATIONS = 20
+    
+    @classmethod
+    def get_image_transform(cls):
+        """Returns the image transformation pipeline."""
+        from PIL import ImageOps
+        return transforms.Compose([
+            transforms.Lambda(lambda img: ImageOps.exif_transpose(img)),
+            transforms.Resize(cls.IMAGE_SIZE),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=cls.NORMALIZATION_MEAN,
+                std=cls.NORMALIZATION_STD
+            )
+        ])
+
+
+# model_loader.py
+import os
+import pickle
+import faiss
+import torch
+import torchvision.models as models
+import warnings
+
+class ModelLoader:
+    """Handles loading of the feature extraction model and FAISS index."""
+    
+    @staticmethod
+    def load_feature_extraction_model():
+        """Loads and configures the EfficientNet model for feature extraction."""
+        print("Loading feature extraction model...")
+        model = models.efficientnet_b0(weights='EfficientNet_B0_Weights.DEFAULT')
+        model.eval()
+        # Remove the classification head
+        model = torch.nn.Sequential(*list(model.children())[:-1])
+        model = model.to(Config.DEVICE)
+        return model
+    
+    @staticmethod
+    def load_index_and_metadata(index_path=None, metadata_path=None):
+        """Loads the FAISS index and metadata from files.
+        
+        Args:
+            index_path (str): Path to the FAISS index file
+            metadata_path (str): Path to the metadata pickle file
+            
+        Returns:
+            tuple: (index, metadata, success_flag)
+        """
+        warnings.filterwarnings("ignore")
+        
+        index_path = index_path or Config.INDEX_PATH
+        metadata_path = metadata_path or Config.METADATA_PATH
+        
+        try:
+            if os.path.exists(index_path) and os.path.exists(metadata_path):
+                index = faiss.read_index(index_path)
+                with open(metadata_path, "rb") as f:
+                    metadata = pickle.load(f)
+                print(f"Index and metadata loaded successfully.")
+                return index, metadata, True
+            else:
+                print(f"Index file or metadata file not found.")
+                return None, {}, False
+        except Exception as e:
+            print(f"Error loading index or metadata: {e}")
+            return None, {}, False
+
+
+# image_processor.py
+import io
+import torch
+import numpy as np
+from PIL import Image
+
+class ImageProcessor:
+    """Handles processing and feature extraction from images."""
+    
+    def __init__(self, model):
+        """Initialize with a pre-trained model.
+        
+        Args:
+            model: The pre-trained model for feature extraction
+        """
+        self.model = model
+        self.transform = Config.get_image_transform()
+    
+    def normalize_image_input(self, image):
+        """Normalize different image input types to a PIL Image.
+        
+        Args:
+            image: Can be a PIL.Image, file path, byte stream, or numpy array
+            
+        Returns:
+            PIL.Image: The normalized image
+        """
+        try:
+            if isinstance(image, str):
+                # If image is a file path
+                return Image.open(image).convert('RGB')
+            elif isinstance(image, bytes) or isinstance(image, io.BytesIO):
+                # If image is a byte stream
+                if isinstance(image, bytes):
+                    image = io.BytesIO(image)
+                return Image.open(image).convert('RGB')
+            elif isinstance(image, np.ndarray):
+                # If image is a numpy array (as from gradio)
+                return Image.fromarray(image.astype('uint8')).convert('RGB')
+            elif isinstance(image, Image.Image):
+                # If image is already a PIL Image
+                return image.convert('RGB')
+            else:
+                raise ValueError(f"Unsupported image type: {type(image)}")
+        except Exception as e:
+            print(f"Error normalizing image: {str(e)}")
+            return None
+    
+    def extract_embedding(self, image):
+        """Extract feature embedding from an image.
+        
+        Args:
+            image: The image to extract features from (various formats accepted)
+            
+        Returns:
+            numpy.ndarray: The feature embedding or None if extraction failed
+        """
+        try:
+            img = self.normalize_image_input(image)
+            if img is None:
+                return None
+                
+            img_tensor = self.transform(img).unsqueeze(0).to(Config.DEVICE)
+            with torch.no_grad():
+                embedding = self.model(img_tensor).squeeze().cpu().numpy()
+            return embedding
+        except Exception as e:
+            print(f"Error extracting embedding: {str(e)}")
+            return None
+
+
+# recommender.py - Already provided in the artifact above
+
+
+# jewelry_recommender.py
+import warnings
+
+class JewelryRecommenderService:
+    """Main service class for the Jewelry Recommender System."""
+    
+    def __init__(self, 
+                index_path=None, 
+                metadata_path=None):
+        """Initialize the jewelry recommender service.
+        
+        Args:
+            index_path (str, optional): Path to FAISS index
+            metadata_path (str, optional): Path to metadata pickle file
+        """
+        warnings.filterwarnings("ignore")
+        
+        # Load the model
+        self.model = ModelLoader.load_feature_extraction_model()
+        
+        # Load index and metadata
+        self.index, self.metadata, success = ModelLoader.load_index_and_metadata(
+            index_path, metadata_path
+        )
+        
+        # Initialize pipeline components
+        self.image_processor = ImageProcessor(self.model)
+        self.recommender = RecommenderEngine(self.index, self.metadata)
+    
+    def get_recommendations(self, image, num_recommendations=None, skip_exact_match=True):
+        """Get recommendations for a query image.
+        
+        Args:
+            image: Query image (various formats)
+            num_recommendations (int, optional): Number of recommendations
+            skip_exact_match (bool): Whether to skip the first/exact match
+            
+        Returns:
+            list: Recommendation results
+        """
+        num_recommendations = num_recommendations or Config.DEFAULT_NUM_RECOMMENDATIONS
+        
+        # Extract embedding from the image
+        embedding = self.image_processor.extract_embedding(image)
+        
+        # Get similar items based on the embedding
+        recommendations = self.recommender.find_similar_items(
+            embedding, num_recommendations, skip_exact_match
+        )
+        
+        return recommendations
+
+
+# formatter.py
+class ResultFormatter:
+    """Formats recommendation results for display."""
+    
+    @staticmethod
+    def format_html(recommendations):
+        """Format recommendations as HTML for the Gradio interface.
+        
+        Args:
+            recommendations (list): List of recommendation dictionaries
+            
+        Returns:
+            str: HTML formatted results
+        """
+        if not recommendations:
+            return "No recommendations found."
+        
+        result_html = "<h3>Recommended Jewelry Items:</h3>"
+        for i, rec in enumerate(recommendations, 1):
+            metadata = rec["metadata"]
+            result_html += f"<div style='margin-bottom:15px; padding:10px; border:1px solid #ddd; border-radius:5px;'>"
+            result_html += f"<h4>#{i}: {metadata.get('name', 'Unknown')}</h4>"
+            result_html += f"<p><b>Category:</b> {metadata.get('category', 'Unknown')}</p>"
+            result_html += f"<p><b>Description:</b> {metadata.get('description', 'No description available')}</p>"
+            result_html += f"<p><b>Price:</b> ${metadata.get('price', 'N/A')}</p>"
+            result_html += f"<p><b>Similarity Score:</b> {rec['similarity_score']:.4f}</p>"
+            if 'image_url' in metadata:
+                result_html += f"<p><img src='{metadata['image_url']}' style='max-width:200px; max-height:200px;'></p>"
+            result_html += "</div>"
+        
+        return result_html
+    
+    @staticmethod
+    def format_json(recommendations):
+        """Format recommendations as JSON.
+        
+        Args:
+            recommendations (list): List of recommendation dictionaries
+            
+        Returns:
+            list: Clean JSON-serializable results
+        """
+        if not recommendations:
+            return []
+        
+        results = []
+        for rec in recommendations:
+            results.append({
+                "item": rec["metadata"].get("name", "Unknown"),
+                "category": rec["metadata"].get("category", "Unknown"),
+                "description": rec["metadata"].get("description", "No description"),
+                "price": rec["metadata"].get("price", "N/A"),
+                "similarity_score": round(rec["similarity_score"], 4),
+                "image_url": rec["metadata"].get("image_url", None)
+            })
+        
+        return results
+
+
+# input_handlers.py
+import io
+import base64
+from PIL import Image
+
+class InputHandlers:
+    """Handles different types of image inputs for recommendation."""
+    
+    @staticmethod
+    def process_image(image, num_recommendations=5, skip_exact_match=True):
+        """Process direct image input.
+        
+        Args:
+            image: The image (PIL, numpy array, etc.)
+            num_recommendations (int): Number of recommendations
+            skip_exact_match (bool): Whether to skip the first/exact match
+            
+        Returns:
+            str: HTML formatted results
+        """
+        recommender = JewelryRecommenderService()
+        recommendations = recommender.get_recommendations(
+            image, num_recommendations, skip_exact_match
+        )
+        return ResultFormatter.format_html(recommendations)
+    
+    @staticmethod
+    def process_url(url, num_recommendations=5, skip_exact_match=True):
+        """Process image from URL.
+        
+        Args:
+            url (str): URL to the image
+            num_recommendations (int): Number of recommendations
+            skip_exact_match (bool): Whether to skip the first/exact match
+            
+        Returns:
+            str: HTML formatted results
+        """
+        try:
+            import requests
+            response = requests.get(url)
+            image = Image.open(io.BytesIO(response.content))
+            return InputHandlers.process_image(image, num_recommendations, skip_exact_match)
+        except Exception as e:
+            return f"Error processing URL: {str(e)}"
+    
+    # Base64 input handler is commented out
+    """
+    @staticmethod
+    def process_base64(base64_string, num_recommendations=5, skip_exact_match=True):
+        # Process base64-encoded image.
+        #
+        # Args:
+        #    base64_string (str): Base64 encoded image
+        #    num_recommendations (int): Number of recommendations
+        #    skip_exact_match (bool): Whether to skip the first/exact match
+        #    
+        # Returns:
+        #    str: HTML formatted results
+        
+        try:
+            # Remove data URL prefix if present
+            if ',' in base64_string:
+                base64_string = base64_string.split(',', 1)[1]
+            
+            image_bytes = base64.b64decode(base64_string)
+            image = Image.open(io.BytesIO(image_bytes))
+            return InputHandlers.process_image(image, num_recommendations, skip_exact_match)
+        except Exception as e:
+            return f"Error processing base64 image: {str(e)}"
+    """
+
+
+# gradio_app.py
+import gradio as gr
+
+def create_gradio_interface():
+    """Create and configure the Gradio web interface.
+    
+    Returns:
+        gradio.Blocks: The configured Gradio interface
+    """
+    with gr.Blocks(title="Jewelry Recommender") as demo:
+        gr.Markdown("# Jewelry Recommendation System")
+        gr.Markdown("Upload an image of jewelry to get similar recommendations.")
+        
+        with gr.Tab("Upload Image"):
+            with gr.Row():
+                image_input = gr.Image(type="pil", label="Upload Jewelry Image")
+                num_recs_slider = gr.Slider(
+                    minimum=1, 
+                    maximum=Config.MAX_RECOMMENDATIONS, 
+                    value=Config.DEFAULT_NUM_RECOMMENDATIONS, 
+                    step=1, 
+                    label="Number of Recommendations"
+                )
+            skip_exact = gr.Checkbox(value=True, label="Skip Exact Match")
+            submit_btn = gr.Button("Get Recommendations")
+            output_html = gr.HTML(label="Recommendations")
+            submit_btn.click(
+                InputHandlers.process_image, 
+                inputs=[image_input, num_recs_slider, skip_exact], 
+                outputs=output_html
+            )
+        
+        with gr.Tab("Image URL"):
+            with gr.Row():
+                url_input = gr.Textbox(label="Enter Image URL")
+                url_num_recs = gr.Slider(
+                    minimum=1, 
+                    maximum=Config.MAX_RECOMMENDATIONS, 
+                    value=Config.DEFAULT_NUM_RECOMMENDATIONS, 
+                    step=1, 
+                    label="Number of Recommendations"
+                )
+            url_skip_exact = gr.Checkbox(value=True, label="Skip Exact Match")
+            url_btn = gr.Button("Get Recommendations from URL")
+            url_output = gr.HTML(label="Recommendations")
+            url_btn.click(
+                InputHandlers.process_url, 
+                inputs=[url_input, url_num_recs, url_skip_exact], 
+                outputs=url_output
+            )
+        
+        # Base64 tab is commented out
+        """
+        with gr.Tab("Base64 Image"):
+            with gr.Row():
+                base64_input = gr.Textbox(label="Enter Base64 Image String")
+                base64_num_recs = gr.Slider(
+                    minimum=1, 
+                    maximum=Config.MAX_RECOMMENDATIONS, 
+                    value=Config.DEFAULT_NUM_RECOMMENDATIONS, 
+                    step=1, 
+                    label="Number of Recommendations"
+                )
+            base64_skip_exact = gr.Checkbox(value=True, label="Skip Exact Match")
+            base64_btn = gr.Button("Get Recommendations from Base64")
+            base64_output = gr.HTML(label="Recommendations")
+            base64_btn.click(
+                InputHandlers.process_base64, 
+                inputs=[base64_input, base64_num_recs, base64_skip_exact], 
+                outputs=base64_output
+            )
+        """
+        
+        gr.Markdown("## How to Use")
+        gr.Markdown("""
+        1. Upload an image of jewelry or provide an image URL
+        2. Adjust the number of recommendations you want to see
+        3. Check "Skip Exact Match" to exclude the identical or closest match from results
+        4. Click the 'Get Recommendations' button
+        5. View similar jewelry items based on visual similarity
+        """)
+        
+    return demo
+
+
+# main.py
+def main():
+    """Main entry point to run the Jewelry Recommender application."""
+    print("Starting Jewelry Recommender System...")
+    demo = create_gradio_interface()
+    demo.launch()
+
+if __name__ == "__main__":
+    main()

#temp_del/end to end proj/.yml

@@ -0,0 +1,117 @@
+# CI/CD Pipeline Configuration for Jewelry Recommender
+
+version: 2.1
+
+jobs:
+  setup:
+    docker:
+      - image: python:3.9
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "requirements.txt" }}
+      - run:
+          name: Install Dependencies
+          command: |
+            python -m pip install --upgrade pip
+            pip install -r requirements.txt
+      - save_cache:
+          paths:
+            - ./venv
+          key: v1-dependencies-{{ checksum "requirements.txt" }}
+          
+  test:
+    docker:
+      - image: python:3.9
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "requirements.txt" }}
+      - run:
+          name: Run Tests
+          command: |
+            python -m unittest discover tests
+            
+  build_model:
+    docker:
+      - image: python:3.9
+    resource_class: large
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "requirements.txt" }}
+      - run:
+          name: Download Dataset
+          command: python data_management.py download
+      - run:
+          name: Train Model and Build Index
+          command: python build_index.py
+      - persist_to_workspace:
+          root: .
+          paths:
+            - model_files/
+            
+  deploy_staging:
+    docker:
+      - image: python:3.9
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Deploy to Staging
+          command: |
+            # Setup GCP authentication
+            echo $GCLOUD_SERVICE_KEY | base64 -d > ${HOME}/gcloud-service-key.json
+            gcloud auth activate-service-account --key-file=${HOME}/gcloud-service-key.json
+            
+            # Deploy to GCP App Engine
+            gcloud app deploy app_staging.yaml --project $GCP_PROJECT_ID --quiet
+            
+  deploy_production:
+    docker:
+      - image: python:3.9
+    steps:
+      - checkout
+      - attach_workspace:
+          at: .
+      - run:
+          name: Deploy to Production
+          command: |
+            # Setup GCP authentication
+            echo $GCLOUD_SERVICE_KEY | base64 -d > ${HOME}/gcloud-service-key.json
+            gcloud auth activate-service-account --key-file=${HOME}/gcloud-service-key.json
+            
+            # Deploy to GCP App Engine
+            gcloud app deploy app.yaml --project $GCP_PROJECT_ID --quiet
+
+workflows:
+  version: 2
+  build-test-deploy:
+    jobs:
+      - setup
+      - test:
+          requires:
+            - setup
+      - build_model:
+          requires:
+            - test
+          filters:
+            branches:
+              only: main
+      - deploy_staging:
+          requires:
+            - build_model
+          filters:
+            branches:
+              only: main
+      - approve_production:
+          type: approval
+          requires:
+            - deploy_staging
+      - deploy_production:
+          requires:
+            - approve_production

#temp_del/end to end proj/clustering-module.py

@@ -0,0 +1,148 @@
+# clustering.py
+
+import numpy as np
+from dataclasses import dataclass
+from typing import Dict, Tuple, List, Optional
+from sklearn.cluster import KMeans
+from sklearn.metrics import silhouette_score, davies_bouldin_score
+from sklearn.preprocessing import StandardScaler
+from tqdm.auto import tqdm
+
+@dataclass
+class ClusterMetrics:
+    n_clusters: int
+    silhouette: float
+    davies_bouldin: float
+    cluster_sizes: Dict[int, int]
+    inertia: float
+
+class EnhancedJewelryClusterer:
+    def __init__(self,
+                 min_clusters: int = 10,
+                 max_clusters: int = 50,
+                 random_state: int = 42):
+        self.min_clusters = min_clusters
+        self.max_clusters = max_clusters
+        self.random_state = random_state
+        self.best_model = None
+        self.cluster_centers_ = None
+        self.scaler = StandardScaler()
+
+    def analyze_jewelry_types(self, metadata: List[Dict]) -> Dict[str, int]:
+        """Analyze distribution of jewelry types in dataset"""
+        type_counts = {}
+        for item in metadata:
+            j_type = item.get('jewelry_type', 'unknown')
+            type_counts[j_type] = type_counts.get(j_type, 0) + 1
+        return type_counts
+
+    def adjust_clusters_by_complexity(self, n_samples: int) -> Tuple[int, int]:
+        """Adjust cluster range based on dataset size and complexity"""
+        # Base calculation
+        suggested_min = max(10, n_samples // 1000)
+        suggested_max = min(50, n_samples // 100)
+
+        # Ensure reasonable bounds
+        final_min = max(self.min_clusters, suggested_min)
+        final_max = min(self.max_clusters, suggested_max)
+        final_min = min(final_min, final_max)  # Ensure min_k <= max_k
+
+        return final_min, final_max
+
+    def evaluate_clustering(self,
+                          embeddings: np.ndarray,
+                          n_clusters: int) -> ClusterMetrics:
+        """Evaluate clustering for a specific number of clusters"""
+        kmeans = KMeans(n_clusters=n_clusters,
+                       random_state=self.random_state,
+                       n_init='auto')
+
+        # Fit and predict
+        labels = kmeans.fit_predict(embeddings)
+
+        # Calculate metrics
+        sil_score = silhouette_score(embeddings, labels)
+        db_score = davies_bouldin_score(embeddings, labels)
+
+        # Get cluster sizes
+        unique, counts = np.unique(labels, return_counts=True)
+        cluster_sizes = dict(zip(unique, counts))
+
+        return ClusterMetrics(
+            n_clusters=n_clusters,
+            silhouette=sil_score,
+            davies_bouldin=db_score,
+            cluster_sizes=cluster_sizes,
+            inertia=kmeans.inertia_
+        )
+
+    def find_optimal_clusters(self,
+                            embeddings: np.ndarray,
+                            metadata: Optional[List[Dict]] = None) -> Dict:
+        """Find optimal number of clusters using multiple metrics"""
+        print("Starting clustering analysis...")
+
+        # Scale the embeddings
+        scaled_embeddings = self.scaler.fit_transform(embeddings)
+
+        # Adjust cluster range based on dataset size
+        min_k, max_k = self.adjust_clusters_by_complexity(len(embeddings))
+        print(f"Analyzing cluster range: {min_k} to {max_k}")
+
+        # Analyze jewelry types if metadata available
+        if metadata:
+            type_distribution = self.analyze_jewelry_types(metadata)
+            print("\nJewelry Type Distribution:")
+            for j_type, count in type_distribution.items():
+                print(f"{j_type}: {count} items ({count/len(metadata)*100:.1f}%)")
+
+        # Evaluate different cluster counts
+        metrics_list = []
+        for k in tqdm(range(min_k, max_k + 1, 2), desc="Evaluating clusters"):
+            metrics = self.evaluate_clustering(scaled_embeddings, k)
+            metrics_list.append(metrics)
+
+        # Find best configuration using combined metric
+        best_metrics = max(metrics_list,
+                         key=lambda x: x.silhouette - x.davies_bouldin * 0.5)
+
+        # Fit final model with optimal clusters
+        final_model = KMeans(n_clusters=best_metrics.n_clusters,
+                           random_state=self.random_state,
+                           n_init='auto')
+        final_labels = final_model.fit_predict(scaled_embeddings)
+
+        # Store best model and cluster centers
+        self.best_model = final_model
+        self.cluster_centers_ = final_model.cluster_centers_
+
+        # Prepare detailed report
+        report = {
+            'optimal_clusters': best_metrics.n_clusters,
+            'silhouette_score': best_metrics.silhouette,
+            'davies_bouldin_score': best_metrics.davies_bouldin,
+            'cluster_distribution': best_metrics.cluster_sizes,
+            'cluster_labels': final_labels,
+            'scaled_embeddings': scaled_embeddings
+        }
+
+        # Print summary
+        print("\nClustering Analysis Results:")
+        print(f"Optimal number of clusters: {report['optimal_clusters']}")
+        print(f"Silhouette Score: {report['silhouette_score']:.3f}")
+        print(f"Davies-Bouldin Score: {report['davies_bouldin_score']:.3f}")
+
+        print("\nCluster Size Distribution:")
+        for cluster, size in report['cluster_distribution'].items():
+            percentage = (size / len(embeddings)) * 100
+            print(f"Cluster {cluster}: {size} items ({percentage:.1f}%)")
+
+        return report
+
+    def predict(self, embeddings: np.ndarray) -> np.ndarray:
+        """Predict clusters for new embeddings"""
+        if self.best_model is None:
+            raise ValueError("Model not fitted. Run find_optimal_clusters first.")
+
+        scaled_embeddings = self.scaler.transform(embeddings)
+        return self.best_model.predict(scaled_embeddings)

#temp_del/end to end proj/data-management-module.py

@@ -0,0 +1,73 @@
+# data_management.py
+
+import os
+import gdown
+import zipfile
+from pathlib import Path
+
+class DataManager:
+    """Handles dataset download, extraction, and validation"""
+    
+    def __init__(self, base_dir="/content/extracted_jewellery_data"):
+        self.base_dir = base_dir
+        self.dataset_path = os.path.join(base_dir, "all images extracted")
+        
+    def setup_dataset_from_drive(self, file_id="1z445s15uuZUysdpyOYjIbWcV0CQrO5fs"):
+        """
+        Downloads and sets up the jewelry dataset from Google Drive shared link
+        Returns the path to the dataset
+        """
+        # Create base directory
+        os.makedirs(self.base_dir, exist_ok=True)
+
+        # Construct the direct download URL
+        url = f"https://drive.google.com/uc?id={file_id}"
+
+        # Download location
+        zip_path = os.path.join(self.base_dir, "jewelry_dataset.zip")
+
+        print("Downloading dataset from Google Drive...")
+        try:
+            # Download the file
+            gdown.download(url, zip_path, quiet=False)
+
+            print("\nExtracting files...")
+            # Extract the zip file
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                zip_ref.extractall(self.base_dir)
+
+            # Remove the zip file to save space
+            os.remove(zip_path)
+
+            # Verify the dataset path exists
+            if os.path.exists(self.dataset_path):
+                print(f"\nDataset successfully downloaded and extracted to: {self.dataset_path}")
+                # Count images
+                image_count = len(list(Path(self.dataset_path).rglob("*.[jJ][pP][gG]")))
+                print(f"Found {image_count} images in the dataset")
+                return self.dataset_path
+            else:
+                print(f"\nError: Expected dataset path not found: {self.dataset_path}")
+                return None
+
+        except Exception as e:
+            print(f"\nError downloading or extracting dataset: {e}")
+            return None
+            
+    def get_all_images(self):
+        """Return list of all image paths in the dataset"""
+        return list(Path(self.dataset_path).rglob("*.[jJ][pP][gG]"))
+        
+    def validate_dataset(self):
+        """Validates that the dataset exists and contains images"""
+        if not os.path.exists(self.dataset_path):
+            print(f"Dataset path does not exist: {self.dataset_path}")
+            return False
+            
+        images = self.get_all_images()
+        if len(images) == 0:
+            print("No images found in the dataset.")
+            return False
+            
+        print(f"Dataset validated: {len(images)} images found.")
+        return True

#temp_del/end to end proj/feature-extraction-module.py

@@ -0,0 +1,67 @@
+# feature_extraction.py
+
+import torch
+import torchvision.models as models
+import torchvision.transforms as transforms
+from PIL import Image, ImageOps
+import numpy as np
+import logging
+import warnings
+
+class FeatureExtractor:
+    """Handles extraction of embeddings from images using a pre-trained model"""
+    
+    def __init__(self, vector_dimension=1280):
+        self.vector_dimension = vector_dimension
+        
+        # Configure logging
+        logging.basicConfig(level=logging.ERROR)
+        self.logger = logging.getLogger(__name__)
+        
+        # Load model
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            self.model = models.efficientnet_b0(weights='EfficientNet_B0_Weights.DEFAULT')
+            self.model.eval()
+            self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = self.model.to(self.device)
+
+        # Image transformation
+        self.transform = transforms.Compose([
+            transforms.Lambda(lambda img: ImageOps.exif_transpose(img)),
+            transforms.Resize((640, 640)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+        
+    def extract_embedding(self, image_path):
+        """Extract embedding vector from an image"""
+        try:
+            with Image.open(image_path).convert('RGB') as img:
+                img_tensor = self.transform(img).unsqueeze(0).to(self.device)
+                with torch.no_grad():
+                    embedding = self.model(img_tensor).squeeze().cpu().numpy()
+                return embedding
+        except Exception as e:
+            self.logger.error(f"Error processing image {image_path}: {str(e)}")
+            return None
+            
+    def batch_extract_embeddings(self, image_paths):
+        """Extract embeddings for a batch of images"""
+        embeddings_list = []
+        valid_paths = []
+        
+        for path in image_paths:
+            embedding = self.extract_embedding(str(path))
+            if embedding is not None:
+                embeddings_list.append(embedding)
+                valid_paths.append(str(path))
+                
+        if embeddings_list:
+            return np.vstack(embeddings_list), valid_paths
+        return None, []

#temp_del/end to end proj/index-storage-module.py

@@ -0,0 +1,99 @@
+# index_storage.py
+
+import os
+import faiss
+import numpy as np
+import pickle
+import pandas as pd
+from typing import List, Tuple, Dict, Optional
+
+class IndexManager:
+    """Manages the FAISS index and metadata storage for efficient similarity search"""
+    
+    def __init__(self, 
+                 vector_dimension: int = 1280,
+                 index_path: str = "./model_files/jewelry_index.idx",
+                 metadata_path: str = "./model_files/jewelry_metadata.pkl",
+                 vectors_path: str = "./model_files/jewelry_vectors.parquet"):
+        
+        self.vector_dimension = vector_dimension
+        self.index_path = index_path
+        self.metadata_path = metadata_path
+        self.vectors_path = vectors_path
+        self.metadata = {}
+        
+        # Initialize FAISS index
+        self.index = faiss.IndexIVFFlat(
+            faiss.IndexFlatL2(vector_dimension),
+            vector_dimension,
+            min(100, max(10, int(vector_dimension * 0.1))),
+            faiss.METRIC_L2
+        )
+        
+    def save_vectors_to_parquet(self, embeddings_array: np.ndarray, image_paths: List[str]):
+        """Save vectors to parquet file with columns for each dimension"""
+        # Create column names for each dimension
+        dim_cols = [f'dim_{i}' for i in range(embeddings_array.shape[1])]
+
+        # Create DataFrame with embeddings
+        df = pd.DataFrame(embeddings_array, columns=dim_cols)
+        df['image_path'] = image_paths
+
+        # Save to parquet
+        os.makedirs(os.path.dirname(self.vectors_path) or '.', exist_ok=True)
+        df.to_parquet(self.vectors_path, index=False)
+        print(f"Vectors saved to {self.vectors_path}")
+
+    def load_vectors_from_parquet(self) -> Tuple[Optional[np.ndarray], Optional[List[str]]]:
+        """Load vectors from parquet file"""
+        if not os.path.exists(self.vectors_path):
+            return None, None
+
+        df = pd.read_parquet(self.vectors_path)
+        image_paths = df['image_path'].tolist()
+        dim_cols = [col for col in df.columns if col.startswith('dim_')]
+        embeddings_array = df[dim_cols].values
+
+        return embeddings_array, image_paths
+
+    def load_index_and_metadata(self) -> bool:
+        """Load index and metadata from files"""
+        try:
+            if os.path.exists(self.index_path) and os.path.exists(self.metadata_path):
+                self.index = faiss.read_index(self.index_path)
+                with open(self.metadata_path, "rb") as f:
+                    self.metadata = pickle.load(f)
+                print("Index and metadata loaded successfully.")
+                return True
+        except Exception as e:
+            print(f"Error loading index or metadata: {e}")
+        return False
+
+    def save_index_and_metadata(self):
+        """Save index and metadata to files"""
+        try:
+            os.makedirs(os.path.dirname(self.index_path) or '.', exist_ok=True)
+            faiss.write_index(self.index, self.index_path)
+            with open(self.metadata_path, "wb") as f:
+                pickle.dump(self.metadata, f)
+            print("Index and metadata saved successfully.")
+        except Exception as e:
+            print(f"Error saving index or metadata: {e}")
+            
+    def build_index(self, embeddings_array: np.ndarray, metadata_list: List[Dict]):
+        """Build FAISS index from embeddings and metadata"""
+        print("Training the index...")
+        self.index.train(embeddings_array)
+
+        print("Adding images to the index...")
+        ids = np.arange(len(metadata_list))
+        self.index.add_with_ids(embeddings_array, ids)
+        self.metadata = {i: meta for i, meta in enumerate(metadata_list)}
+        
+        self.save_index_and_metadata()
+        print(f"Successfully indexed {len(metadata_list)} images")
+        
+    def search(self, query_embedding: np.ndarray, k: int = 5) -> Tuple[np.ndarray, np.ndarray]:
+        """Search the index for similar vectors"""
+        search_k = min(k, self.index.ntotal)
+        return self.index.search(query_embedding.reshape(1, -1), search_k)

#temp_del/end to end proj/main-module.py

@@ -0,0 +1,88 @@
+# main.py
+
+import os
+import argparse
+from pathlib import Path
+
+from data_management import DataManager
+from recommendation import JewelryRecommender
+import ui
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="Jewelry Recommendation System")
+    parser.add_argument("--dataset", type=str, default="./extracted_jewellery_data",
+                        help="Path to dataset directory")
+    parser.add_argument("--model-dir", type=str, default="./model_files",
+                        help="Directory to store model files")
+    parser.add_argument("--rebuild-index", action="store_true",
+                        help="Force rebuilding the index even if it exists")
+    parser.add_argument("--interface", type=str, default="colab",
+                        choices=["colab", "gradio", "none"],
+                        help="Type of interface to launch")
+    return parser.parse_args()
+
+def main():
+    """Main function to run the Jewelry Recommendation System"""
+    args = parse_args()
+    
+    # Setup paths
+    dataset_path = args.dataset
+    model_dir = args.model_dir
+    os.makedirs(model_dir, exist_ok=True)
+    
+    index_path = os.path.join(model_dir, "jewelry_index.idx")
+    metadata_path = os.path.join(model_dir, "jewelry_metadata.pkl")
+    vectors_path = os.path.join(model_dir, "jewelry_vectors.parquet")
+    
+    # Setup dataset if needed
+    if not os.path.exists(dataset_path) or not os.listdir(dataset_path):
+        print("Dataset not found or empty. Downloading dataset...")
+        data_manager = DataManager(dataset_path)
+        dataset_path = data_manager.setup_dataset_from_drive()
+        if not dataset_path:
+            print("Failed to download dataset. Exiting.")
+            return
+    
+    # Initialize recommender
+    recommender = JewelryRecommender(
+        dataset_path=dataset_path,
+        index_path=index_path,
+        metadata_path=metadata_path,
+        vectors_path=vectors_path
+    )
+    
+    # Build or load index
+    index_exists = os.path.exists(index_path) and os.path.exists(metadata_path)
+    if args.rebuild_index or not index_exists:
+        print("Building new index...")
+        recommender.build_index()
+    else:
+        print("Loading existing index...")
+        if not recommender.index_manager.load_index_and_metadata():
+            print("Failed to load existing index. Building new index...")
+            recommender.build_index()
+    
+    # Launch interface
+    if args.interface == "colab":
+        try:
+            ui.create_colab_interface(recommender)
+        except Exception as e:
+            print(f"Failed to create Colab interface: {e}")
+            print("Are you running in a Colab environment?")
+    elif args.interface == "gradio":
+        try:
+            import gradio as gr
+            interface = ui.create_gradio_interface(recommender)
+            interface.launch()
+        except ImportError:
+            print("Gradio not installed. Install with: pip install gradio")
+    else:
+        print("No interface launched. System is ready for programmatic use.")
+        print("Example usage:")
+        print("  from recommendation import JewelryRecommender")
+        print("  recommender = JewelryRecommender()")
+        print("  recommender.get_recommendations('path/to/image.jpg')")
+
+if __name__ == "__main__":
+    main()

#temp_del/end to end proj/recommendation-module.py

@@ -0,0 +1,164 @@
+# recommendation.py
+
+import os
+from typing import List, Dict, Optional
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from pathlib import Path
+
+from feature_extraction import FeatureExtractor
+from index_storage import IndexManager
+from clustering import EnhancedJewelryClusterer
+from data_management import DataManager
+
+class JewelryRecommender:
+    """Jewelry recommendation system that combines feature extraction, clustering, and indexing"""
+    
+    def __init__(self,
+                dataset_path: str = "",
+                vector_dimension: int = 1280,
+                index_path: str = "./model_files/jewelry_index.idx",
+                metadata_path: str = "./model_files/jewelry_metadata.pkl",
+                vectors_path: str = "./model_files/jewelry_vectors.parquet"):
+
+        self.dataset_path = dataset_path
+        self.extractor = FeatureExtractor(vector_dimension)
+        self.index_manager = IndexManager(
+            vector_dimension=vector_dimension,
+            index_path=index_path,
+            metadata_path=metadata_path,
+            vectors_path=vectors_path
+        )
+        
+        # Load index and metadata if available
+        self.index_manager.load_index_and_metadata()
+        
+    @property
+    def metadata(self):
+        return self.index_manager.metadata
+        
+    @metadata.setter
+    def metadata(self, value):
+        self.index_manager.metadata = value
+
+    def enhanced_auto_categorize_images(self, embeddings_array: np.ndarray) -> np.ndarray:
+        """Auto-categorize images using enhanced clustering techniques"""
+        clusterer = EnhancedJewelryClusterer()
+        clustering_report = clusterer.find_optimal_clusters(
+            embeddings_array,
+            metadata=list(self.metadata.values()) if hasattr(self, 'metadata') else None
+        )
+
+        # Store clustering information in metadata
+        self.index_manager.metadata['clustering_info'] = {
+            'optimal_clusters': clustering_report['optimal_clusters'],
+            'silhouette_score': clustering_report['silhouette_score'],
+            'davies_bouldin_score': clustering_report['davies_bouldin_score'],
+            'cluster_centers': clusterer.cluster_centers_.tolist()
+        }
+
+        return clustering_report['cluster_labels']
+
+    def build_index(self):
+        """Build the search index from the dataset images"""
+        data_manager = DataManager(self.dataset_path)
+        all_images = data_manager.get_all_images()
+        total_images = len(all_images)
+        
+        if total_images == 0:
+            print("No images found in the dataset. Exiting index building.")
+            return
+
+        # Extract features
+        print("Extracting features from images...")
+        embeddings_array, image_paths = self.extractor.batch_extract_embeddings(all_images)
+        
+        if embeddings_array is None:
+            print("Failed to extract embeddings. Exiting index building.")
+            return
+            
+        # Save vectors
+        self.index_manager.save_vectors_to_parquet(embeddings_array, image_paths)
+
+        # Create metadata
+        metadata_list = []
+        for path in image_paths:
+            path_obj = Path(path)
+            metadata = {
+                "full_path": str(path),
+                "filename": path_obj.name
+            }
+            metadata_list.append(metadata)
+
+        # Auto-categorize images
+        categories = self.enhanced_auto_categorize_images(embeddings_array)
+        for meta, cat in zip(metadata_list, categories):
+            meta["category"] = f"Category_{cat}"
+
+        # Build the index
+        self.index_manager.build_index(embeddings_array, metadata_list)
+
+    def get_recommendations(self, query_image_path: str, num_recommendations: int = 5) -> List[Dict]:
+        """Get recommendations for a query image"""
+        query_embedding = self.extractor.extract_embedding(query_image_path)
+        if query_embedding is None:
+            return []
+
+        distances, indices = self.index_manager.search(query_embedding, num_recommendations * 3)
+
+        results = []
+        seen_categories = set()
+
+        for dist, idx in zip(distances[0], indices[0]):
+            if idx != -1:
+                metadata = self.metadata[idx]
+                if metadata["full_path"] != query_image_path:
+                    similarity_score = 1 / (1 + float(dist))
+                    if metadata.get("category") not in seen_categories:
+                        result = {
+                            "metadata": metadata,
+                            "distance": float(dist),
+                            "similarity_score": similarity_score
+                        }
+                        results.append(result)
+                        seen_categories.add(metadata.get("category"))
+
+        results.sort(key=lambda x: x["similarity_score"], reverse=True)
+        return results[:num_recommendations]
+
+    def display_recommendations(self, query_image_path: str, num_recommendations: int = 5):
+        """Display recommendations with visualization"""
+        recommendations = self.get_recommendations(query_image_path, num_recommendations)
+
+        if not recommendations:
+            print("No recommendations found.")
+            return
+
+        plt.figure(figsize=(20, 5))
+
+        plt.subplot(1, num_recommendations + 1, 1)
+        query_img = Image.open(query_image_path).convert('RGB')
+        plt.imshow(query_img)
+        plt.title('Query Image', fontsize=10)
+        plt.axis('off')
+
+        for idx, result in enumerate(recommendations, 2):
+            plt.subplot(1, num_recommendations + 1, idx)
+            img_path = result['metadata']['full_path']
+            img = Image.open(img_path).convert('RGB')
+            plt.imshow(img)
+
+            similarity = result['similarity_score']
+            plt.title(f"Match {idx-1}\nSimilarity: {similarity:.3f}\nCategory: {result['metadata'].get('category', 'N/A')}",
+                      fontsize=8)
+            plt.axis('off')
+
+        plt.tight_layout()
+        plt.show()
+
+        print("\nDetailed Recommendations:")
+        for idx, result in enumerate(recommendations, 1):
+            print(f"\n{idx}. Category: {result['metadata'].get('category', 'N/A')}")
+            print(f"   Similarity Score: {result['similarity_score']:.3f}")
+            print(f"   File: {result['metadata']['filename']}")

#temp_del/end to end proj/requirements.txt

@@ -0,0 +1,16 @@
+# requirements.txt
+torch>=2.0.0
+torchvision>=0.15.0
+faiss-cpu>=1.7.0
+scikit-learn>=1.0.0
+numpy>=1.20.0
+pandas>=1.3.0
+pyarrow>=7.0.0
+matplotlib>=3.5.0
+Pillow>=9.0.0
+tqdm>=4.60.0
+ipywidgets>=7.7.0
+gdown>=4.5.0
+gradio>=3.0.0
+concurrent-log-handler>=0.9.20
+plotly>=5.10.0

#temp_del/end to end proj/ui-module.py

@@ -0,0 +1,113 @@
+# ui.py
+
+import ipywidgets as widgets
+from IPython.display import display, clear_output, HTML
+from google.colab import files
+from pathlib import Path
+
+def create_colab_interface(recommender):
+    """Create an interactive interface for the recommender in Colab"""
+    output_area = widgets.Output()
+
+    def on_upload_button_clicked(b):
+        with output_area:
+            clear_output()
+            print("Upload an image to get recommendations")
+            uploaded = files.upload()
+
+            if uploaded:
+                filename = list(uploaded.keys())[0]
+                try:
+                    recommender.display_recommendations(filename)
+                except Exception as e:
+                    print(f"Error processing image: {e}")
+
+    def on_sample_button_clicked(b):
+        with output_area:
+            clear_output()
+            dataset_images = list(Path(recommender.dataset_path).rglob("*.[jJ][pP][gG]"))
+
+            if dataset_images:
+                sample_image = str(dataset_images[0])
+                print(f"Using sample image: {sample_image}")
+                recommender.display_recommendations(sample_image)
+            else:
+                print("No sample images found in the dataset.")
+
+    upload_button = widgets.Button(
+        description='Upload Image',
+        button_style='primary',
+        layout=widgets.Layout(width='200px')
+    )
+
+    sample_button = widgets.Button(
+        description='Use Sample Image',
+        button_style='success',
+        layout=widgets.Layout(width='200px')
+    )
+
+    upload_button.on_click(on_upload_button_clicked)
+    sample_button.on_click(on_sample_button_clicked)
+
+    box = widgets.VBox([
+        widgets.HTML("<h2>Jewelry Recommendation System</h2>"),
+        widgets.HBox([upload_button, sample_button]),
+        output_area
+    ])
+
+    display(box)
+
+# For web-based deployments (not Colab)
+try:
+    import gradio as gr
+except ImportError:
+    pass
+else:
+    def create_gradio_interface(recommender):
+        """Create a Gradio interface for web deployment"""
+        def process_image(image):
+            # Save the uploaded image temporarily
+            temp_path = "temp_upload.jpg"
+            image.save(temp_path)
+            
+            # Get recommendations
+            recommendations = recommender.get_recommendations(temp_path)
+            
+            # Format results
+            results = []
+            for idx, rec in enumerate(recommendations, 1):
+                img_path = rec["metadata"]["full_path"]
+                similarity = rec["similarity_score"]
+                category = rec["metadata"].get("category", "N/A")
+                
+                results.append({
+                    "image": img_path,
+                    "similarity": f"{similarity:.3f}",
+                    "category": category
+                })
+                
+            return results
+            
+        # Create Gradio interface
+        with gr.Blocks() as interface:
+            gr.Markdown("# Jewelry Recommendation System")
+            
+            with gr.Row():
+                input_image = gr.Image(type="pil", label="Upload Jewelry Image")
+                
+            submit_btn = gr.Button("Get Recommendations")
+            
+            output_gallery = gr.Gallery(
+                label="Recommendations", 
+                show_label=True,
+                columns=5,
+                object_fit="contain"
+            )
+            
+            submit_btn.click(
+                fn=process_image,
+                inputs=input_image,
+                outputs=output_gallery
+            )
+            
+        return interface

#temp_del/oldapp.py

@@ -0,0 +1,231 @@
+# import faiss
+# import numpy as np
+# import pickle
+# import torch
+# import torchvision.transforms as transforms
+# import torchvision.models as models
+# from PIL import Image, ImageOps
+# import os
+# import warnings
+# import io
+# import base64
+# import gradio as gr
+
+# class JewelryRecommenderServing:
+#     def __init__(self,
+#                  vector_dimension: int = 1280,
+#                  index_path: str = "rootdir/trained_models/jewelry_index.idx",
+#                  metadata_path: str = "rootdir/trained_models/jewelry_metadata.pkl"):
+        
+#         warnings.filterwarnings("ignore")
+        
+#         # Load index and metadata
+#         self.index_path = index_path
+#         self.metadata_path = metadata_path
+#         self.index = None
+#         self.metadata = {}
+        
+#         # Load model for feature extraction
+#         self.model = models.efficientnet_b0(weights='EfficientNet_B0_Weights.DEFAULT')
+#         self.model.eval()
+#         self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+        
+#         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+#         self.model = self.model.to(self.device)
+        
+#         # Image transformation
+#         self.transform = transforms.Compose([
+#             transforms.Lambda(lambda img: ImageOps.exif_transpose(img)),
+#             transforms.Resize((640, 640)),
+#             transforms.ToTensor(),
+#             transforms.Normalize(
+#                 mean=[0.485, 0.456, 0.406],
+#                 std=[0.229, 0.224, 0.225]
+#             )
+#         ])
+        
+#         # Load the existing index and metadata
+#         self.load_index_and_metadata()
+    
+#     def load_index_and_metadata(self) -> bool:
+#         """Load the pre-built FAISS index and metadata from files"""
+#         try:
+#             if os.path.exists(self.index_path) and os.path.exists(self.metadata_path):
+#                 self.index = faiss.read_index(self.index_path)
+#                 with open(self.metadata_path, "rb") as f:
+#                     self.metadata = pickle.load(f)
+#                 print(f"Index and metadata loaded successfully from {self.index_path} and {self.metadata_path}.")
+#                 return True
+#             else:
+#                 print(f"Index file or metadata file not found at {self.index_path} or {self.metadata_path}")
+#                 return False
+#         except Exception as e:
+#             print(f"Error loading index or metadata: {e}")
+#             return False
+    
+#     def _extract_embedding(self, image) -> np.ndarray:
+#         """Extract embedding from an image using the pre-trained model
+        
+#         Parameters:
+#         - image: Can be a PIL.Image object, file path, or byte stream
+#         """
+#         try:
+#             # Handle different input types
+#             if isinstance(image, str):
+#                 # If image is a file path
+#                 img = Image.open(image).convert('RGB')
+#             elif isinstance(image, bytes) or isinstance(image, io.BytesIO):
+#                 # If image is a byte stream
+#                 if isinstance(image, bytes):
+#                     image = io.BytesIO(image)
+#                 img = Image.open(image).convert('RGB')
+#             elif isinstance(image, np.ndarray):
+#                 # If image is a numpy array (as from gradio)
+#                 img = Image.fromarray(image.astype('uint8')).convert('RGB')
+#             elif isinstance(image, Image.Image):
+#                 # If image is already a PIL Image
+#                 img = image.convert('RGB')
+#             else:
+#                 raise ValueError(f"Unsupported image type: {type(image)}")
+            
+#             # Process image
+#             img_tensor = self.transform(img).unsqueeze(0).to(self.device)
+#             with torch.no_grad():
+#                 embedding = self.model(img_tensor).squeeze().cpu().numpy()
+#             return embedding
+#         except Exception as e:
+#             print(f"Error processing image: {str(e)}")
+#             return None
+    
+#     def get_recommendations(self, image, num_recommendations: int = 5):
+#         """Get recommendations for a query image based on similarity
+        
+#         Parameters:
+#         - image: Can be a PIL.Image object, file path, or byte stream
+#         - num_recommendations: Number of recommendations to return
+#         """
+#         if self.index is None:
+#             print("Index not loaded. Please check that the index path is correct.")
+#             return []
+        
+#         query_embedding = self._extract_embedding(image)
+#         if query_embedding is None:
+#             return []
+        
+#         # Perform the similarity search
+#         search_k = min(num_recommendations * 3, self.index.ntotal)
+#         distances, indices = self.index.search(query_embedding.reshape(1, -1), search_k)
+        
+#         results = []
+#         seen_categories = set()
+        
+#         for dist, idx in zip(distances[0], indices[0]):
+#             if idx != -1:
+#                 metadata = self.metadata[idx]
+#                 # No need to check for query_image_path anymore since we're handling objects
+#                 similarity_score = 1 / (1 + float(dist))
+#                 if metadata.get("category") not in seen_categories:
+#                     result = {
+#                         "metadata": metadata,
+#                         "distance": float(dist),
+#                         "similarity_score": similarity_score
+#                     }
+#                     results.append(result)
+#                     seen_categories.add(metadata.get("category"))
+        
+#         results.sort(key=lambda x: x["similarity_score"], reverse=True)
+#         return results[:num_recommendations]
+
+# def format_results(recommendations):
+#     """Format the recommendation results for display in the Gradio interface"""
+#     if not recommendations:
+#         return "No recommendations found."
+    
+#     result_html = "<h3>Recommended Jewelry Items:</h3>"
+#     for i, rec in enumerate(recommendations, 1):
+#         metadata = rec["metadata"]
+#         result_html += f"<div style='margin-bottom:15px; padding:10px; border:1px solid #ddd; border-radius:5px;'>"
+#         result_html += f"<h4>#{i}: {metadata.get('name', 'Unknown')}</h4>"
+#         result_html += f"<p><b>Category:</b> {metadata.get('category', 'Unknown')}</p>"
+#         result_html += f"<p><b>Description:</b> {metadata.get('description', 'No description available')}</p>"
+#         result_html += f"<p><b>Price:</b> ${metadata.get('price', 'N/A')}</p>"
+#         result_html += f"<p><b>Similarity Score:</b> {rec['similarity_score']:.4f}</p>"
+#         if 'image_url' in metadata:
+#             result_html += f"<p><img src='{metadata['image_url']}' style='max-width:200px; max-height:200px;'></p>"
+#         result_html += "</div>"
+    
+#     return result_html
+
+# def process_image(image, num_recommendations=5):
+#     """Process the image and return recommendations"""
+#     recommender = JewelryRecommenderServing()
+#     recommendations = recommender.get_recommendations(image, num_recommendations)
+#     return format_results(recommendations)
+
+# def process_url(url, num_recommendations=5):
+#     """Process an image from a URL and return recommendations"""
+#     try:
+#         import requests
+#         response = requests.get(url)
+#         image = Image.open(io.BytesIO(response.content))
+#         return process_image(image, num_recommendations)
+#     except Exception as e:
+#         return f"Error processing URL: {str(e)}"
+
+# def process_base64(base64_string, num_recommendations=5):
+#     """Process a base64-encoded image and return recommendations"""
+#     try:
+#         # Remove data URL prefix if present
+#         if ',' in base64_string:
+#             base64_string = base64_string.split(',', 1)[1]
+        
+#         image_bytes = base64.b64decode(base64_string)
+#         image = Image.open(io.BytesIO(image_bytes))
+#         return process_image(image, num_recommendations)
+#     except Exception as e:
+#         return f"Error processing base64 image: {str(e)}"
+
+# # Create Gradio interface
+# def create_gradio_interface():
+#     with gr.Blocks(title="Jewelry Recommender") as demo:
+#         gr.Markdown("# Jewelry Recommendation System")
+#         gr.Markdown("Upload an image of jewelry to get similar recommendations.")
+        
+#         with gr.Tab("Upload Image"):
+#             with gr.Row():
+#                 image_input = gr.Image(type="pil", label="Upload Jewelry Image")
+#                 num_recs_slider = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Number of Recommendations")
+#             submit_btn = gr.Button("Get Recommendations")
+#             output_html = gr.HTML(label="Recommendations")
+#             submit_btn.click(process_image, inputs=[image_input, num_recs_slider], outputs=output_html)
+        
+#         with gr.Tab("Image URL"):
+#             with gr.Row():
+#                 url_input = gr.Textbox(label="Enter Image URL")
+#                 url_num_recs = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Number of Recommendations")
+#             url_btn = gr.Button("Get Recommendations from URL")
+#             url_output = gr.HTML(label="Recommendations")
+#             url_btn.click(process_url, inputs=[url_input, url_num_recs], outputs=url_output)
+        
+#         with gr.Tab("Base64 Image"):
+#             with gr.Row():
+#                 base64_input = gr.Textbox(label="Enter Base64 Image String")
+#                 base64_num_recs = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Number of Recommendations")
+#             base64_btn = gr.Button("Get Recommendations from Base64")
+#             base64_output = gr.HTML(label="Recommendations")
+#             base64_btn.click(process_base64, inputs=[base64_input, base64_num_recs], outputs=base64_output)
+        
+#         gr.Markdown("## How to Use")
+#         gr.Markdown("""
+#         1. Upload an image of jewelry, provide an image URL, or paste a base64-encoded image
+#         2. Adjust the number of recommendations you want to see
+#         3. Click the 'Get Recommendations' button
+#         4. View similar jewelry items based on visual similarity
+#         """)
+        
+#     return demo
+
+# # For Hugging Face Spaces deployment
+# if __name__ == "__main__":
+#     demo = create_gradio_interface()
+#     demo.launch()

#temp_del/rawsnippet.py

@@ -0,0 +1,121 @@
+import faiss
+import numpy as np
+import pickle
+import torch
+import torchvision.transforms as transforms
+import torchvision.models as models
+from PIL import Image, ImageOps
+import os
+import warnings
+
+class JewelryRecommenderServing:
+    def __init__(self,
+                 vector_dimension: int = 1280,
+                 index_path: str = "/path/to/jewelry_index.idx",
+                 metadata_path: str = "/path/to/jewelry_metadata.pkl"):
+        
+        warnings.filterwarnings("ignore")
+        
+        # Load index and metadata
+        self.index_path = index_path
+        self.metadata_path = metadata_path
+        self.index = None
+        self.metadata = {}
+        
+        # Load model for feature extraction
+        self.model = models.efficientnet_b0(weights='EfficientNet_B0_Weights.DEFAULT')
+        self.model.eval()
+        self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
+        
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = self.model.to(self.device)
+        
+        # Image transformation
+        self.transform = transforms.Compose([
+            transforms.Lambda(lambda img: ImageOps.exif_transpose(img)),
+            transforms.Resize((640, 640)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+        
+        # Load the existing index and metadata
+        self.load_index_and_metadata()
+    
+    def load_index_and_metadata(self) -> bool:
+        """Load the pre-built FAISS index and metadata from files"""
+        try:
+            if os.path.exists(self.index_path) and os.path.exists(self.metadata_path):
+                self.index = faiss.read_index(self.index_path)
+                with open(self.metadata_path, "rb") as f:
+                    self.metadata = pickle.load(f)
+                print("Index and metadata loaded successfully.")
+                return True
+            else:
+                print(f"Index file or metadata file not found at {self.index_path} or {self.metadata_path}")
+                return False
+        except Exception as e:
+            print(f"Error loading index or metadata: {e}")
+            return False
+    
+    def _extract_embedding(self, image_path: str) -> np.ndarray:
+        """Extract embedding from an image using the pre-trained model"""
+        try:
+            with Image.open(image_path).convert('RGB') as img:
+                img_tensor = self.transform(img).unsqueeze(0).to(self.device)
+                with torch.no_grad():
+                    embedding = self.model(img_tensor).squeeze().cpu().numpy()
+                return embedding
+        except Exception as e:
+            print(f"Error processing image {image_path}: {str(e)}")
+            return None
+    
+    def get_recommendations(self, query_image_path: str, num_recommendations: int = 5):
+        """Get recommendations for a query image based on similarity"""
+        if self.index is None:
+            print("Index not loaded. Please check that the index path is correct.")
+            return []
+        
+        query_embedding = self._extract_embedding(query_image_path)
+        if query_embedding is None:
+            return []
+        
+        # Perform the similarity search
+        search_k = min(num_recommendations * 3, self.index.ntotal)
+        distances, indices = self.index.search(query_embedding.reshape(1, -1), search_k)
+        
+        results = []
+        seen_categories = set()
+        
+        for dist, idx in zip(distances[0], indices[0]):
+            if idx != -1:
+                metadata = self.metadata[idx]
+                if metadata["full_path"] != query_image_path:
+                    similarity_score = 1 / (1 + float(dist))
+                    if metadata.get("category") not in seen_categories:
+                        result = {
+                            "metadata": metadata,
+                            "distance": float(dist),
+                            "similarity_score": similarity_score
+                        }
+                        results.append(result)
+                        seen_categories.add(metadata.get("category"))
+        
+        results.sort(key=lambda x: x["similarity_score"], reverse=True)
+        return results[:num_recommendations]
+
+
+# Usage example:
+def serve_recommendations(image_path, num_recommendations=5):
+    # Initialize the recommender with paths to your saved files
+    recommender = JewelryRecommenderServing(
+        index_path="/path/to/jewelry_index.idx",
+        metadata_path="/path/to/jewelry_metadata.pkl"
+    )
+    
+    # Get recommendations
+    recommendations = recommender.get_recommendations(image_path, num_recommendations)
+    
+    return recommendations

app.py

@@ -0,0 +1,11 @@
+# main.py
+from gradio_app import create_gradio_interface
+
+def main():
+    """Main entry point to run the Jewelry Recommender application."""
+    print("Starting Jewelry Recommender System...")
+    demo = create_gradio_interface()
+    demo.launch()
+
+if __name__ == "__main__":
+    main()

app.yml

@@ -0,0 +1,74 @@
+title: Jewelry Recommender
+emoji: 💎
+colorFrom: purple
+colorTo: pink
+sdk: gradio
+sdk_version: 3.50.2
+app_file: updatedcode/app.py
+pinned: false
+license: mit
+duplicated_from: null
+models:
+  - efficientnet
+  - faiss
+python_version: 3.9
+datasets:
+  - None
+tags:
+  - image-similarity
+  - jewelry
+  - recommendation-system
+  - computer-vision
+
+# Gradio configuration
+gradio:
+  theme: default
+  dark_background: False
+  live: False
+  capture_session: False
+  allow_flagging: never
+  queue_concurrency_count: 1
+  max_file_size: 10
+
+# System dependencies
+dependencies:
+  -torch>=2.0.0
+  -torchvision>=0.15.0
+  -faiss-cpu>=1.7.0
+  -scikit-learn>=1.0.0
+  -numpy>=1.20.0
+  -pandas>=1.3.0
+  -pyarrow>=7.0.0
+  -matplotlib>=3.5.0
+  -Pillow>=9.0.0
+  -tqdm>=4.60.0
+  -ipywidgets>=7.7.0
+  -gdown>=4.5.0
+  -gradio>=3.0.0
+  -concurrent-log-handler>=0.9.20
+  -plotly>=5.10.0
+
+
+# Space hardware
+hardware:
+  accelerator: cpu
+  cpu: 2
+  memory: 16GB
+
+# Required files for the application
+files:
+  - app.py
+  - jewelry_index.idx
+  - jewelry_metadata.pkl
+  - README.md
+
+# Documentation
+information:
+  description: >
+    This Jewelry Recommender app uses computer vision to find similar jewelry items 
+    based on a reference image. Upload an image of jewelry, provide an image URL, 
+    or paste a base64-encoded image to get visually similar recommendations.
+    The system uses an EfficientNet model for feature extraction and FAISS for fast similarity search.
+  license: MIT
+  author: Maazuddin
+  repository: https://github.com/Maazuddin1/jewelry-recommender

backend/jewelry_recomm_service.py

@@ -0,0 +1,55 @@
+# jewelry_recommender.py
+import warnings
+from config import Config
+
+from supportingfiles.model_loader import ModelLoader
+from supportingfiles.image_processor import ImageProcessor
+from supportingfiles.recommender import RecommenderEngine
+
+class JewelryRecommenderService:
+    """Main service class for the Jewelry Recommender System."""
+    
+    def __init__(self, 
+                index_path=None, 
+                metadata_path=None):
+        """Initialize the jewelry recommender service.
+        
+        Args:
+            index_path (str, optional): Path to FAISS index
+            metadata_path (str, optional): Path to metadata pickle file
+        """
+        warnings.filterwarnings("ignore")
+        
+        # Load the model
+        self.model = ModelLoader.load_feature_extraction_model()
+        
+        # Load index and metadata
+        self.index, self.metadata, success = ModelLoader.load_index_and_metadata(
+            index_path, metadata_path
+        )
+        
+        # Initialize pipeline components
+        self.image_processor = ImageProcessor(self.model)
+        self.recommender = RecommenderEngine(self.index, self.metadata)
+    
+    def get_recommendations(self, image, num_recommendations=None):
+        """Get recommendations for a query image.
+        
+        Args:
+            image: Query image (various formats)
+            num_recommendations (int, optional): Number of recommendations
+            
+        Returns:
+            list: Recommendation results
+        """
+        num_recommendations = num_recommendations or Config.DEFAULT_NUM_RECOMMENDATIONS
+        
+        # Extract embedding from the image
+        embedding = self.image_processor.extract_embedding(image)
+        
+        # Get similar items based on the embedding
+        recommendations = self.recommender.find_similar_items(
+            embedding, num_recommendations
+        )
+        
+        return recommendations

backend/supportingfiles/image_processor.py

@@ -0,0 +1,70 @@
+# image_processor.py
+import io
+import torch
+import numpy as np
+from PIL import Image
+from config import Config
+
+class ImageProcessor:
+    """Handles processing and feature extraction from images."""
+    
+    def __init__(self, model):
+        """Initialize with a pre-trained model.
+        
+        Args:
+            model: The pre-trained model for feature extraction
+        """
+        self.model = model
+        self.transform = Config.get_image_transform()
+    
+    def normalize_image_input(self, image):
+        """Normalize different image input types to a PIL Image.
+        
+        Args:
+            image: Can be a PIL.Image, file path, byte stream, or numpy array
+            
+        Returns:
+            PIL.Image: The normalized image
+        """
+        try:
+            if isinstance(image, str):
+                # If image is a file path
+                return Image.open(image).convert('RGB')
+            elif isinstance(image, bytes) or isinstance(image, io.BytesIO):
+                # If image is a byte stream
+                if isinstance(image, bytes):
+                    image = io.BytesIO(image)
+                return Image.open(image).convert('RGB')
+            elif isinstance(image, np.ndarray):
+                # If image is a numpy array (as from gradio)
+                return Image.fromarray(image.astype('uint8')).convert('RGB')
+            elif isinstance(image, Image.Image):
+                # If image is already a PIL Image
+                return image.convert('RGB')
+            else:
+                raise ValueError(f"Unsupported image type: {type(image)}")
+        except Exception as e:
+            print(f"Error normalizing image: {str(e)}")
+            return None
+    
+    def extract_embedding(self, image):
+        """Extract feature embedding from an image.
+        
+        Args:
+            image: The image to extract features from (various formats accepted)
+            
+        Returns:
+            numpy.ndarray: The feature embedding or None if extraction failed
+        """
+        try:
+            img = self.normalize_image_input(image)
+            if img is None:
+                return None
+                
+            img_tensor = self.transform(img).unsqueeze(0).to(Config.DEVICE)
+            with torch.no_grad():
+                embedding = self.model(img_tensor).squeeze().cpu().numpy()
+            return embedding
+        except Exception as e:
+            print(f"Error extracting embedding: {str(e)}")
+            return None

backend/supportingfiles/model_loader.py

@@ -0,0 +1,52 @@
+# model_loader.py
+import os
+import pickle
+import faiss
+import torch
+import torchvision.models as models
+import warnings
+from config import Config
+
+class ModelLoader:
+    """Handles loading of the feature extraction model and FAISS index."""
+    
+    @staticmethod
+    def load_feature_extraction_model():
+        """Loads and configures the EfficientNet model for feature extraction."""
+        print("Loading feature extraction model...")
+        model = models.efficientnet_b0(weights='EfficientNet_B0_Weights.DEFAULT')
+        model.eval()
+        # Remove the classification head
+        model = torch.nn.Sequential(*list(model.children())[:-1])
+        model = model.to(Config.DEVICE)
+        return model
+    
+    @staticmethod
+    def load_index_and_metadata(index_path=None, metadata_path=None):
+        """Loads the FAISS index and metadata from files.
+        
+        Args:
+            index_path (str): Path to the FAISS index file
+            metadata_path (str): Path to the metadata pickle file
+            
+        Returns:
+            tuple: (index, metadata, success_flag)
+        """
+        warnings.filterwarnings("ignore")
+        
+        index_path = index_path or Config.INDEX_PATH
+        metadata_path = metadata_path or Config.METADATA_PATH
+        
+        try:
+            if os.path.exists(index_path) and os.path.exists(metadata_path):
+                index = faiss.read_index(index_path)
+                with open(metadata_path, "rb") as f:
+                    metadata = pickle.load(f)
+                print(f"Index and metadata loaded successfully.")
+                return index, metadata, True
+            else:
+                print(f"Index file or metadata file not found.")
+                return None, {}, False
+        except Exception as e:
+            print(f"Error loading index or metadata: {e}")
+            return None, {}, False

backend/supportingfiles/recommender.py

@@ -0,0 +1,67 @@
+# recommender.py
+import numpy as np
+from config import Config
+
+class RecommenderEngine:
+    """Engine for finding similar jewelry items based on image embeddings."""
+    
+    def __init__(self, index, metadata):
+        """Initialize with FAISS index and metadata.
+        
+        Args:
+            index: FAISS index for similarity search
+            metadata (dict): Metadata for the indexed items
+        """
+        self.index = index
+        self.metadata = metadata
+    
+    def find_similar_items(self, embedding, num_recommendations=None, skip_exact_match=True):
+        """Find similar items based on embedding vector.
+        
+        Args:
+            embedding (numpy.ndarray): The query embedding vector
+            num_recommendations (int): Number of recommendations to return
+            skip_exact_match (bool): Whether to skip the first result (exact match)
+            
+        Returns:
+            list: Sorted list of recommendation dictionaries
+        """
+        if self.index is None:
+            print("Error: Index not loaded")
+            return []
+            
+        if embedding is None:
+            print("Error: Invalid embedding")
+            return []
+        
+        num_recommendations = num_recommendations or Config.DEFAULT_NUM_RECOMMENDATIONS
+        
+        # Calculate how many items to retrieve based on whether we're skipping the first match
+        search_k = num_recommendations
+        if skip_exact_match:
+            search_k += 1
+        
+        # Get exact number of results we need
+        distances, indices = self.index.search(embedding.reshape(1, -1), search_k)
+        
+        results = []
+        
+        # Start from index 1 to skip the first result (closest match) if skip_exact_match is True
+        start_idx = 1 if skip_exact_match and len(indices[0]) > 1 else 0
+        
+        for dist, idx in zip(distances[0][start_idx:], indices[0][start_idx:]):
+            if idx != -1:
+                metadata = self.metadata[idx]
+                similarity_score = 1 / (1 + float(dist))
+                
+                # Add item to results without category filtering
+                result = {
+                    "metadata": metadata,
+                    "distance": float(dist),
+                    "similarity_score": similarity_score
+                }
+                results.append(result)
+        
+        # Sort by similarity score (highest first)
+        results.sort(key=lambda x: x["similarity_score"], reverse=True)
+        return results[:num_recommendations]

config.py

@@ -0,0 +1,38 @@
+# config.py
+import os
+import torch
+import torchvision.transforms as transforms
+
+class Config:
+    """Configuration class for the Jewelry Recommender System."""
+    
+    # Model settings
+    VECTOR_DIMENSION = 1280
+    INDEX_PATH = "rootdir/trained_models/jewelry_index.idx"
+    METADATA_PATH = "rootdir/trained_models/jewelry_metadata.pkl"
+    
+    # Hardware settings
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # Image processing settings
+    IMAGE_SIZE = (640, 640)
+    NORMALIZATION_MEAN = [0.485, 0.456, 0.406]
+    NORMALIZATION_STD = [0.229, 0.224, 0.225]
+    
+    # Recommendation settings
+    DEFAULT_NUM_RECOMMENDATIONS = 5
+    MAX_RECOMMENDATIONS = 20
+    
+    @classmethod
+    def get_image_transform(cls):
+        """Returns the image transformation pipeline."""
+        from PIL import ImageOps
+        return transforms.Compose([
+            transforms.Lambda(lambda img: ImageOps.exif_transpose(img)),
+            transforms.Resize(cls.IMAGE_SIZE),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=cls.NORMALIZATION_MEAN,
+                std=cls.NORMALIZATION_STD
+            )
+        ])

frontend/gradio_app.py

@@ -0,0 +1,82 @@
+# gradio_app.py
+import gradio as gr
+from input_handlers import InputHandlers
+from config import Config
+
+def create_gradio_interface():
+    """Create and configure the Gradio web interface.
+    
+    Returns:
+        gradio.Blocks: The configured Gradio interface
+    """
+    with gr.Blocks(title="Jewelry Recommender") as demo:
+        gr.Markdown("# Jewelry Recommendation System")
+        gr.Markdown("Upload an image of jewelry to get similar recommendations.")
+        
+        with gr.Tab("Upload Image"):
+            with gr.Row():
+                image_input = gr.Image(type="pil", label="Upload Jewelry Image")
+                num_recs_slider = gr.Slider(
+                    minimum=1, 
+                    maximum=Config.MAX_RECOMMENDATIONS, 
+                    value=Config.DEFAULT_NUM_RECOMMENDATIONS, 
+                    step=1, 
+                    label="Number of Recommendations"
+                )
+            skip_exact = gr.Checkbox(value=True, label="Skip Exact Match")
+            submit_btn = gr.Button("Get Recommendations")
+            output_html = gr.HTML(label="Recommendations")
+            submit_btn.click(
+                InputHandlers.process_image, 
+                inputs=[image_input, num_recs_slider, skip_exact], 
+                outputs=output_html
+            )
+        
+        with gr.Tab("Image URL"):
+            with gr.Row():
+                url_input = gr.Textbox(label="Enter Image URL")
+                url_num_recs = gr.Slider(
+                    minimum=1, 
+                    maximum=Config.MAX_RECOMMENDATIONS, 
+                    value=Config.DEFAULT_NUM_RECOMMENDATIONS, 
+                    step=1, 
+                    label="Number of Recommendations"
+                )
+            url_skip_exact = gr.Checkbox(value=True, label="Skip Exact Match")
+            url_btn = gr.Button("Get Recommendations from URL")
+            url_output = gr.HTML(label="Recommendations")
+            url_btn.click(
+                InputHandlers.process_url, 
+                inputs=[url_input, url_num_recs, url_skip_exact], 
+                outputs=url_output
+            )
+        
+        with gr.Tab("Base64 Image"):
+            with gr.Row():
+                base64_input = gr.Textbox(label="Enter Base64 Image String")
+                base64_num_recs = gr.Slider(
+                    minimum=1, 
+                    maximum=Config.MAX_RECOMMENDATIONS, 
+                    value=Config.DEFAULT_NUM_RECOMMENDATIONS, 
+                    step=1, 
+                    label="Number of Recommendations"
+                )
+            base64_skip_exact = gr.Checkbox(value=True, label="Skip Exact Match")
+            base64_btn = gr.Button("Get Recommendations from Base64")
+            base64_output = gr.HTML(label="Recommendations")
+            base64_btn.click(
+                InputHandlers.process_base64, 
+                inputs=[base64_input, base64_num_recs, base64_skip_exact], 
+                outputs=base64_output
+            )
+        
+        gr.Markdown("## How to Use")
+        gr.Markdown("""
+        1. Upload an image of jewelry, provide an image URL, or paste a base64-encoded image
+        2. Adjust the number of recommendations you want to see
+        3. Check "Skip Exact Match" to exclude the identical or closest match from results
+        4. Click the 'Get Recommendations' button
+        5. View similar jewelry items based on visual similarity
+        """)
+        
+    return demo

frontend/input_handlers.py

@@ -0,0 +1,70 @@
+# input_handlers.py
+import io
+import base64
+from PIL import Image
+from backend.jewelry_recomm_service import JewelryRecommenderService
+from utils.formatter import ResultFormatter
+
+class InputHandlers:
+    """Handles different types of image inputs for recommendation."""
+    
+    @staticmethod
+    def process_image(image, num_recommendations=5, skip_exact_match=True):
+        """Process direct image input.
+        
+        Args:
+            image: The image (PIL, numpy array, etc.)
+            num_recommendations (int): Number of recommendations
+            skip_exact_match (bool): Whether to skip the first/exact match
+            
+        Returns:
+            str: HTML formatted results
+        """
+        recommender = JewelryRecommenderService()
+        recommendations = recommender.get_recommendations(
+            image, num_recommendations, skip_exact_match
+        )
+        return ResultFormatter.format_html(recommendations)
+    
+    @staticmethod
+    def process_url(url, num_recommendations=5, skip_exact_match=True):
+        """Process image from URL.
+        
+        Args:
+            url (str): URL to the image
+            num_recommendations (int): Number of recommendations
+            skip_exact_match (bool): Whether to skip the first/exact match
+            
+        Returns:
+            str: HTML formatted results
+        """
+        try:
+            import requests
+            response = requests.get(url)
+            image = Image.open(io.BytesIO(response.content))
+            return InputHandlers.process_image(image, num_recommendations, skip_exact_match)
+        except Exception as e:
+            return f"Error processing URL: {str(e)}"
+    
+    @staticmethod
+    def process_base64(base64_string, num_recommendations=5, skip_exact_match=True):
+        """Process base64-encoded image.
+        
+        Args:
+            base64_string (str): Base64 encoded image
+            num_recommendations (int): Number of recommendations
+            skip_exact_match (bool): Whether to skip the first/exact match
+            
+        Returns:
+            str: HTML formatted results
+        """
+        try:
+            # Remove data URL prefix if present
+            if ',' in base64_string:
+                base64_string = base64_string.split(',', 1)[1]
+            
+            image_bytes = base64.b64decode(base64_string)
+            image = Image.open(io.BytesIO(image_bytes))
+            return InputHandlers.process_image(image, num_recommendations, skip_exact_match)
+        except Exception as e:
+            return f"Error processing base64 image: {str(e)}"

models/jewelry_metadata.pkl

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

requirements.txt

@@ -0,0 +1,17 @@
+# requirements.txt
+torch>=2.0.0
+torchvision>=0.15.0
+faiss-cpu>=1.7.0
+scikit-learn>=1.0.0
+numpy>=1.20.0
+pandas>=1.3.0
+pyarrow>=7.0.0
+matplotlib>=3.5.0
+Pillow>=9.0.0
+tqdm>=4.60.0
+ipywidgets>=7.7.0
+gdown>=4.5.0
+gradio>=3.0.0
+concurrent-log-handler>=0.9.20
+plotly>=5.10.0
+requests

utils/formatter.py

@@ -0,0 +1,58 @@
+# formatter.py
+
+class ResultFormatter:
+    """Formats recommendation results for display."""
+    
+    @staticmethod
+    def format_html(recommendations):
+        """Format recommendations as HTML for the Gradio interface.
+        
+        Args:
+            recommendations (list): List of recommendation dictionaries
+            
+        Returns:
+            str: HTML formatted results
+        """
+        if not recommendations:
+            return "No recommendations found."
+        
+        result_html = "<h3>Recommended Jewelry Items:</h3>"
+        for i, rec in enumerate(recommendations, 1):
+            metadata = rec["metadata"]
+            result_html += f"<div style='margin-bottom:15px; padding:10px; border:1px solid #ddd; border-radius:5px;'>"
+            result_html += f"<h4>#{i}: {metadata.get('name', 'Unknown')}</h4>"
+            result_html += f"<p><b>Category:</b> {metadata.get('category', 'Unknown')}</p>"
+            result_html += f"<p><b>Description:</b> {metadata.get('description', 'No description available')}</p>"
+            result_html += f"<p><b>Price:</b> ${metadata.get('price', 'N/A')}</p>"
+            result_html += f"<p><b>Similarity Score:</b> {rec['similarity_score']:.4f}</p>"
+            if 'image_url' in metadata:
+                result_html += f"<p><img src='{metadata['image_url']}' style='max-width:200px; max-height:200px;'></p>"
+            result_html += "</div>"
+        
+        return result_html
+    
+    @staticmethod
+    def format_json(recommendations):
+        """Format recommendations as JSON.
+        
+        Args:
+            recommendations (list): List of recommendation dictionaries
+            
+        Returns:
+            list: Clean JSON-serializable results
+        """
+        if not recommendations:
+            return []
+        
+        results = []
+        for rec in recommendations:
+            results.append({
+                "item": rec["metadata"].get("name", "Unknown"),
+                "category": rec["metadata"].get("category", "Unknown"),
+                "description": rec["metadata"].get("description", "No description"),
+                "price": rec["metadata"].get("price", "N/A"),
+                "similarity_score": round(rec["similarity_score"], 4),
+                "image_url": rec["metadata"].get("image_url", None)
+            })
+        
+        return results