feat(init): :tada: Initial commit pushing up app data

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.9-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 

embeddings/pokemon_embeddings_pkmn.pkl

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

requirements.txt

@@ -1,3 +1,68 @@
-altair
-pandas
-streamlit
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.9.0
+attrs==25.3.0
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.4.26
+charset-normalizer==3.4.2
+click==8.2.1
+colorama==0.4.6
+fastapi==0.109.2
+filelock==3.18.0
+fsspec==2025.5.1
+gitdb==4.0.12
+gitpython==3.1.44
+h11==0.16.0
+huggingface-hub==0.32.2
+idna==3.10
+jinja2==3.1.6
+jsonschema==4.24.0
+jsonschema-specifications==2025.4.1
+markdown-it-py==3.0.0
+markupsafe==3.0.2
+mdurl==0.1.2
+mpmath==1.3.0
+narwhals==1.41.0
+networkx==3.4.2
+numpy==2.2.6
+packaging==23.2
+pandas==2.2.3
+pillow==11.2.1
+protobuf==4.25.8
+pyarrow==20.0.0
+pydantic==2.11.5
+pydantic-core==2.33.2
+pydeck==0.9.1
+pygments==2.19.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.9
+pytz==2025.2
+pyyaml==6.0.2
+referencing==0.36.2
+regex==2024.11.6
+requests==2.31.0
+rich==13.9.4
+rpds-py==0.25.1
+safetensors==0.5.3
+setuptools==69.2.0
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+starlette==0.36.3
+streamlit==1.32.0
+sympy==1.14.0
+tenacity==8.5.0
+tokenizers==0.21.1
+toml==0.10.2
+torch==2.7.0
+torchvision==0.22.0
+tornado==6.5.1
+tqdm==4.67.1
+transformers==4.52.3
+typing-extensions==4.13.2
+typing-inspection==0.4.1
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.27.1
+watchdog==6.0.0

src/similarity.py

@@ -0,0 +1,284 @@
+import torch
+import pickle
+from PIL import Image
+import io
+import os
+import requests
+import base64
+from collections import defaultdict
+from transformers import ViTModel, ViTImageProcessor
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import logging
+# logging.disable(logging.WARNING)
+transformers_logger = logging.getLogger('transformers')
+transformers_logger.setLevel(logging.ERROR)
+
+
+
+# Change current dir to the execution place
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+DB_PATH_STRUCTURE = 'embeddings/pokemon_embeddings_pkmn.pkl'
+
+
+
+
+
+# --- Device Selection ---
+# Hint: Check for CUDA, MPS, or fallback to CPU
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+
+
+# --- Load Pretrained Model ---
+def get_model() -> ViTModel:
+    """
+    TODO: Implement model loading
+    - Load a pretrained model (e.g., ResNet18)
+    - Remove the classification head
+    - Set the model to evaluation mode
+    - Move the model to the appropriate device
+    
+    Returns:
+        torch.nn.Module: The prepared model
+    """
+
+    model = ViTModel.from_pretrained('imjeffhi/pokemon_classifier').to(device)
+
+
+    return model.eval()
+
+
+
+
+
+# --- Image Preprocessing ---
+# TODO: Define your image transformation pipeline
+# Hint: Consider resizing, normalization, and tensor conversion
+transform = ViTImageProcessor.from_pretrained(get_model().name_or_path)
+
+
+
+
+
+class PokemonSimilarity:
+    def __init__(self, suppress_init_logs: bool = True) -> None:
+        """
+        TODO: Initialize the similarity engine
+        - Load the model
+        - Load the database of Pokemon embeddings
+        """
+        self.original_transformers_level = transformers_logger.level
+        self.original_root_level = logging.root.level
+
+        if suppress_init_logs:
+            # Temporarily raise the logging level for transformers and root logger
+            # to silence startup messages during model/DB loading
+            transformers_logger.setLevel(logging.ERROR)
+            logging.root.setLevel(logging.WARNING) # Suppress INFO from other sources too
+
+        try:
+            self.model = get_model()
+            self.db = self._load_db()
+        
+        finally:
+            # Always restore original logging levels after initialization
+            transformers_logger.setLevel(self.original_transformers_level)
+            logging.root.setLevel(self.original_root_level)
+
+
+
+    def _load_db(self) -> dict | None:
+        """
+        TODO: Implement database loading
+        - Look for the embeddings file in different possible locations
+        - Load the pickle file containing Pokemon embeddings
+        - Handle cases where the file is not found
+        
+        Returns:
+            list: List of dictionaries containing Pokemon embeddings and labels
+        """
+        
+        db_path = None
+
+        try:
+
+            if os.path.exists(DB_PATH_STRUCTURE):
+                db_path = DB_PATH_STRUCTURE
+
+            if os.path.exists(f'../{DB_PATH_STRUCTURE}'):
+                db_path = f'../{DB_PATH_STRUCTURE}'
+            
+            with open(db_path, 'rb') as f:
+                # Load the dictionary from the file
+                embeddings = pickle.load(f)
+
+            return embeddings
+        
+        except Exception as e:
+            raise os.error(f'Error loading embeddings database: {e}')
+
+
+
+    def load_image(self, image_input) -> Image.Image:
+        """
+        Handle different input formats:
+        - URL strings
+        - Base64 encoded image strings
+        - Bytes objects
+        - PIL Image objects
+        
+        Args:
+            image_input: Image in various formats
+            
+        Returns:
+            PIL.Image: The loaded image in RGB format
+        """
+        if isinstance(image_input, Image.Image):
+            # Already a PIL Image object
+            return image_input.convert('RGB')
+
+        elif isinstance(image_input, str): 
+            # Check if it's a local file path
+            if os.path.exists(image_input):
+                try:
+                    return Image.open(image_input).convert('RGB')
+                
+                except Image.UnidentifiedImageError as e:
+                    raise Image.UnidentifiedImageError(f"Cannot identify image file at path '{image_input}': {e}")
+                
+                except Exception as e:
+                    raise ValueError(f"Error loading image from local file path '{image_input}': {e}")
+
+            # Check if it's a URL
+            elif image_input.startswith(('http://', 'https://')):
+                try:
+                    response = requests.get(image_input, stream=True)
+                    response.raise_for_status() # Raise an exception for bad status codes
+                    return Image.open(io.BytesIO(response.content)).convert('RGB')
+                
+                except requests.RequestException as e:
+                    raise requests.RequestException(f"Error loading image from URL '{image_input}': {e}")
+                
+                except Exception as e:
+                    raise ValueError(f"Error processing image from URL '{image_input}': {e}")
+
+            # Check if it's a Base64 encoded string
+            try:
+                # Base64 strings often include a prefix like "data:image/jpeg;base64,"
+                # We need to remove that prefix before decoding.
+                if ',' in image_input:
+                    _, base64_data = image_input.split(',', 1)
+                else:
+                    base64_data = image_input
+
+                decoded_image = base64.b64decode(base64_data)
+                return Image.open(io.BytesIO(decoded_image)).convert('RGB')
+            
+            except (base64.binascii.Error, ValueError) as e:
+                # If it's not a valid Base64, it might just be an unsupported string
+                # We'll let the final ValueError catch it if no other type matches.
+                pass # Continue to check other types or raise final error
+
+        elif isinstance(image_input, bytes):
+            # Bytes object
+            try:
+                return Image.open(io.BytesIO(image_input)).convert('RGB')
+            
+            except Exception as e:
+                raise ValueError(f'Error loading image from bytes object: {e}')
+
+        raise ValueError(f'Unsupported image input format: {type(image_input)}. Expected URL, Base64 string, bytes, or PIL Image.')
+
+
+
+    def get_embedding(self, image) -> torch.Tensor:
+        """
+        Generate a feature vector for the input image using the model
+        
+        Args:
+            image (PIL.Image): Input image to generate embedding for
+            
+        Returns:
+            numpy.ndarray: The image embedding
+        """
+        
+        inputs = transform(images=image, return_tensors="pt").to(device)
+
+        last_hidden_state = self.model(**inputs).last_hidden_state
+
+        return last_hidden_state.reshape(last_hidden_state.shape[0], -1)
+
+
+    def cosine_similarity(self, a, b) -> float:
+        """
+        Calculate the cosine similarity between two vectors
+        
+        Args:
+            a: First vector
+            b: Second vector
+            
+        Returns:
+            float: Cosine similarity score
+        """
+        
+        return float(torch.nn.functional.cosine_similarity(a, b, dim=1))
+
+
+    def find_closest_pokemon(self, image_input):
+        """
+        1. Load the input image
+        2. Generate its embedding
+        3. Compare with all Pokemon embeddings in the database
+        4. Return the name of the most similar Pokemon
+        
+        Args:
+            image_input: Image in various formats (URL, base64, bytes, PIL Image)
+            
+        Returns:
+            str: Name of the most similar Pokemon
+        """
+
+        # Load the input_image
+        image = self.load_image(image_input)
+
+        # Generate embedding for the input image
+        input_emb = self.get_embedding(image)
+
+        # Compute similarities with all database entries
+        similarities = []
+        for label, emb_list in self.db.items():
+            for emb in emb_list:
+                similarities.append((
+                    label,
+                    self.cosine_similarity(input_emb, emb)
+                ))
+
+        # Sort by similarity, descending
+        similarities.sort(key=lambda x: x[1], reverse=True)
+
+        # Majority voting
+        data = lambda: defaultdict(float)
+        summary = defaultdict(data)
+        for label, similarity in similarities[:5]:
+            summary[label]['votes'] += 1
+            summary[label]['max_sim'] = max(summary[label]['max_sim'], similarity)
+
+        # Sort by votes, descending. In draw case prior max_similarity
+        sorted_votes = [(label, data['votes'], data['max_sim']) for label, data in summary.items()]
+        sorted_votes.sort(key=lambda x: (x[1], x[2]), reverse=True)
+
+        return sorted_votes[0][0]
+
+
+
+
+
+if __name__ == "__main__":
+    similarity_engine = PokemonSimilarity()
+    print(similarity_engine.find_closest_pokemon('https://alfabetajuega.com/hero/2019/03/Squirtle-Looking-Happy.jpg?width=1200&aspect_ratio=16:9')) 
+    # print(similarity_engine.find_closest_pokemon(r'C:\python\intro_deep_learning\hackathon\solutions\grupo_delante\data\testing\charmander\charmander.jpeg')) 
+    

src/streamlit_app.py

@@ -1,40 +1,113 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from PIL import Image
+from similarity import PokemonSimilarity
+import logging
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+
+INPUT_UPLOAD = 'upload'
+INPUT_URL = 'url'
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+# Set page config first
+st.set_page_config(
+    page_title='Pokemon Similarity Finder',
+    page_icon='🎮',
+    layout='centered'
+)
+
+
+# Initialize the similarity engine
+@st.cache_resource
+def get_similarity_engine() -> PokemonSimilarity:
+    logger.info('Initializing similarity engine...')
+    engine = PokemonSimilarity()
+    logger.info('Similarity engine initialized successfully')
+    return engine
+
+
+similarity_engine = get_similarity_engine()
+
+
+# Title and description
+st.title('🎮 Pokemon Similarity Finder')
+st.markdown("""
+Upload an image of a Pokemon or provide an image URL and we'll find the closest match in our database!
+""")
+
+
+# --- Input Method Selection ---
+input_method = st.radio(
+    'Choose input method:',
+    ('Upload Image', 'Image URL'),
+    horizontal=True
+)
+
+
+# --- Initialize variables for shared logic ---
+input_type = None
+image_to_process = None
+# request_payload = None
+# request_files = None
+
+
+if input_method == 'Upload Image':
+    uploaded_file = st.file_uploader('Choose a Pokemon image...', type=['jpg', 'jpeg', 'png'])
+
+    if uploaded_file is not None:
+        logger.info(f'File uploaded: {uploaded_file.name}')
+        input_type = INPUT_UPLOAD
+        image_input = uploaded_file.getvalue()
+        image_to_process = Image.open(uploaded_file)
+        # request_files = {'file': (uploaded_file.name, uploaded_file.getvalue(), uploaded_file.type)}
+
+
+if input_method == 'Image URL':
+    image_url = st.text_input('Enter Image URL:')
+
+    if image_url:
+        logger.info(f'Image URL provided: {image_url}')
+        input_type = INPUT_URL
+        image_input = image_url
+        image_to_process = image_url
+        # request_payload = json.dumps({'url': image_url})
+
+
+
+if image_to_process is not None:
+    try:
+        st.image(image_to_process, caption=f'Image from {input_type}', use_column_width=True)
+        logger.info(f'Successfully displayed {input_type} image')
+
+    except Exception as e:
+        logger.error(f'Error loading image: {str(e)}')
+        st.error(f'❌ Error loading image: {str(e)}')
+        st.info('Please make sure you have uploaded a valid image file.')
+
+
+    # Add a button to trigger the similarity search
+    if st.button('Find Similar Pokemon', use_container_width=True):
+        logger.info('Find Similar Pokemon button clicked')
+        predicted_pokemon = None # Reset prediction
+
+        with st.spinner('Analyzing image...'):
+            try:
+                logger.info(f'Finding closest Pokemon match using {input_type} input...')
+                
+                predicted_pokemon = similarity_engine.find_closest_pokemon(image_input)
+
+            except Exception as e:
+                logger.error(f'Error during Pokemon matching: {str(e)}')
+                st.error(f'❌ An error occurred: {str(e)}')
+                st.info('Please try uploading a different image, using a different URL, or try again later.')
+
+        if predicted_pokemon:
+            logger.info(f'Found closest Pokemon: {predicted_pokemon}')
+            st.success(f'🎯 The closest Pokemon is: **{predicted_pokemon.title()}**')
+            st.balloons()