Update working verion

.pre-commit-config.yaml

@@ -5,8 +5,6 @@ repos:
       - id: trailing-whitespace
       - id: end-of-file-fixer
         exclude: docs/badges
-      - id: check-added-large-files
-        args: ["--maxkb=1024"] # allow up to 1MB
       - id: check-json
       - id: check-yaml
         args: ["--unsafe"] # needed for some mkdocs extensions

src/app.py

@@ -0,0 +1,370 @@
+import gradio as gr
+import pandas as pd
+from pathlib import Path
+from typing import Optional
+import os
+from datasets import load_dataset
+from PIL import Image
+import io
+
+from src.modules.vlm_inference import analyze_product_image
+from src.modules.data_processing import pil_to_base64
+from src.modules.evals import run_inference_on_dataframe
+
+# Constants
+AVAILABLE_MODELS = {
+    "Qwen2.5-VL-32B": "accounts/fireworks/models/qwen2p5-vl-32b-instruct",
+    "Llama Maverick": "accounts/fireworks/models/llama4-maverick-instruct-basic",
+    "Llama Scout": "accounts/fireworks/models/llama4-scout-instruct-basic",
+}
+
+EXAMPLE_IMAGES_DIR = Path("data/examples")
+MAX_CONCURRENT_REQUESTS = 10
+
+FILE_PATH = Path(__file__).parents[1]
+ASSETS_PATH = FILE_PATH / "assets"
+
+
+def analyze_single_image(
+    image_input, model_name: str, api_key: Optional[str] = None
+) -> tuple[str, str, str, str]:
+    """
+    Process a single product image and return classification results
+
+    Args:
+        image_input: PIL Image or file path
+        model_name: Selected model name
+        api_key: Optional API key override
+
+    Returns:
+        tuple: (master_category, gender, sub_category, description)
+    """
+    if image_input is None:
+        return "No image provided", "", "", ""
+
+    try:
+        # Convert PIL Image to base64
+        img_b64 = pil_to_base64(image_input)
+
+        # Determine provider from model name
+        model_id = AVAILABLE_MODELS[model_name]
+
+        # Get API key from environment if not provided
+        if api_key is None:
+            api_key = os.getenv("FIREWORKS_API_KEY")
+
+        result = analyze_product_image(
+            image_url=img_b64, model=model_id, api_key=api_key, provider="Fireworks"
+        )
+
+        # Format results
+        master_cat = result.master_category
+        gender = result.gender
+        sub_cat = result.sub_category
+        description = result.description
+
+        return master_cat, gender, sub_cat, description
+
+    except Exception as e:
+        error_msg = f"Error: {str(e)}"
+        return error_msg, "", "", ""
+
+
+def process_batch_dataset(
+    csv_file,
+    model_name: str,
+    api_key: Optional[str] = None,
+    max_concurrent: int = MAX_CONCURRENT_REQUESTS,
+) -> tuple[pd.DataFrame, str]:
+    """
+    Process uploaded CSV dataset with product images
+
+    Args:
+        csv_file: Uploaded CSV file with image data
+        model_name: Selected model name
+        api_key: Optional API key override
+        max_concurrent: Max concurrent API requests
+
+    Returns:
+        tuple: (results_dataframe, summary_statistics)
+    """
+    if csv_file is None:
+        return None, "No dataset uploaded"
+
+    try:
+        # Load dataset
+        df = pd.read_csv(csv_file.name)
+
+        # Validate required columns
+        required_cols = ["id", "image"]
+        if not all(col in df.columns for col in required_cols):
+            return None, f"Dataset must contain columns: {required_cols}"
+
+        # Determine provider
+        model_id = AVAILABLE_MODELS[model_name]
+
+        # Get API key
+        if api_key is None:
+            api_key = os.getenv("FIREWORKS_API_KEY")
+
+        # Run batch inference
+        results_df = run_inference_on_dataframe(
+            df=df,
+            model=model_id,
+            api_key=api_key,
+            provider="Fireworks",
+            max_concurrent_requests=max_concurrent,
+        )
+
+        # Generate summary statistics
+        total_processed = len(results_df)
+        successful = results_df["pred_masterCategory"].notna().sum()
+        failed = total_processed - successful
+
+        summary = f"""
+        Batch Processing Complete:
+        - Total images: {total_processed}
+        - Successfully classified: {successful}
+        - Failed: {failed}
+        - Success rate: {(successful / total_processed) * 100:.1f}%
+        """
+
+        return results_df, summary
+
+    except Exception as e:
+        return None, f"Error processing dataset: {str(e)}"
+
+
+def load_example_data() -> pd.DataFrame:
+    """Load example product images from HuggingFace dataset"""
+    # Load dataset from HuggingFace
+    ds = load_dataset("ceyda/fashion-products-small")
+    df = ds["train"].to_pandas()
+
+    # Select 20 random samples
+    sample_df = df.sample(n=20, random_state=42).reset_index(drop=True)
+
+    # Keep only relevant columns for display
+    display_df = sample_df[["id", "masterCategory", "gender", "subCategory"]].copy()
+    display_df["image_data"] = sample_df["image"]
+
+    return display_df
+
+
+def get_image_from_row(examples_df: pd.DataFrame, evt: gr.SelectData) -> Image.Image:
+    """Get PIL Image from selected row in examples table"""
+    if evt.index is None or len(evt.index) == 0:
+        return None
+
+    row_idx = evt.index[0]
+    if row_idx >= len(examples_df):
+        return None
+
+    # Get the image data from the stored row
+    image_data = examples_df.iloc[row_idx]["image_data"]
+
+    # Convert to PIL Image if it's a dict (from HuggingFace datasets)
+    if isinstance(image_data, dict):
+        if "bytes" in image_data:
+            return Image.open(io.BytesIO(image_data["bytes"]))
+        elif "path" in image_data:
+            return Image.open(image_data["path"])
+
+    # Return as-is if already a PIL Image
+    return image_data
+
+
+def create_demo_interface():
+    """
+    Create the Gradio interface with custom theme and layout
+    """
+    # Load example data at startup
+    example_data = load_example_data()
+
+    with gr.Blocks(
+        title="Product Catalog Cleansing",
+        theme=gr.themes.Soft(),
+    ) as demo:
+        # Store examples dataframe in state
+        examples_state = gr.State(value=example_data)
+
+        # Header
+        gr.Markdown(
+            """
+            # Product Catalog Cleansing
+
+            Automate product classification, attribute extraction, and catalog enrichment
+            using state-of-the-art multimodal AI. Fine-tuned SOTA OSS models on FireworksAI.
+            """
+        )
+
+        # Model Selection (shared across tabs)
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Powered by")
+                gr.Image(
+                    value=str(ASSETS_PATH / "fireworks_logo.png"),
+                    height=60,
+                    width=200,
+                    show_label=False,
+                    show_download_button=False,
+                    container=False,
+                    show_fullscreen_button=False,
+                    show_share_button=False,
+                )
+
+            model_selector = gr.Dropdown(
+                choices=list(AVAILABLE_MODELS.keys()),
+                value=list(AVAILABLE_MODELS.keys())[0],
+                label="Select Model",
+            )
+            api_key_input = gr.Textbox(
+                label="API Key",
+                type="password",
+            )
+
+        with gr.Tabs():
+            with gr.TabItem("📸 Single Image Analysis"):
+                gr.Markdown("### Upload a product image for instant classification")
+
+                with gr.Row():
+                    # Left column - Input
+                    with gr.Column(scale=1):
+                        image_input = gr.Image(
+                            label="Upload Product Image", type="pil", height=400
+                        )
+                        analyze_btn = gr.Button(
+                            "🔍 Analyze Product", variant="primary", size="lg"
+                        )
+
+                    # Right column - Results
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Classification Results")
+                        master_category_output = gr.Textbox(
+                            label="Master Category", interactive=False
+                        )
+                        gender_output = gr.Textbox(label="Gender", interactive=False)
+                        subcategory_output = gr.Textbox(
+                            label="Sub-Category", interactive=False
+                        )
+                        description_output = gr.Textbox(
+                            label="AI-Generated Description", interactive=False, lines=4
+                        )
+
+                # Example Products Table
+                gr.Markdown("### 📚 Example Products (Click a row to load image)")
+                examples_table = gr.Dataframe(
+                    value=example_data[
+                        ["id", "masterCategory", "gender", "subCategory"]
+                    ],
+                    label="Select a product to analyze",
+                    interactive=False,
+                    wrap=True,
+                )
+
+                # Wire up single image analysis
+                analyze_btn.click(
+                    fn=analyze_single_image,
+                    inputs=[image_input, model_selector, api_key_input],
+                    outputs=[
+                        master_category_output,
+                        gender_output,
+                        subcategory_output,
+                        description_output,
+                    ],
+                )
+
+                # Allow clicking table row to load image
+                examples_table.select(
+                    fn=get_image_from_row,
+                    inputs=[examples_state],
+                    outputs=[image_input],
+                )
+
+                with gr.Row():
+                    # Left - Upload
+                    with gr.Column(scale=1):
+                        dataset_upload = gr.File(
+                            label="Upload Dataset (CSV)", file_types=[".csv"]
+                        )
+                        concurrent_slider = gr.Slider(
+                            minimum=1,
+                            maximum=50,
+                            value=10,
+                            step=1,
+                            label="Concurrent Requests",
+                            info="Higher = faster but may hit rate limits",
+                        )
+                        process_btn = gr.Button(
+                            "⚡ Process Dataset", variant="primary", size="lg"
+                        )
+
+                    # Right - Results summary
+                    with gr.Column(scale=1):
+                        summary_output = gr.Textbox(
+                            label="Processing Summary", interactive=False, lines=8
+                        )
+
+                # Results dataframe
+                results_dataframe = gr.Dataframe(
+                    label="Classification Results", interactive=False, wrap=True
+                )
+
+                # Wire up batch processing
+                process_btn.click(
+                    fn=process_batch_dataset,
+                    inputs=[
+                        dataset_upload,
+                        model_selector,
+                        api_key_input,
+                        concurrent_slider,
+                    ],
+                    outputs=[results_dataframe, summary_output],
+                )
+
+            # Tab 3: Model Evaluation (show uploaded charts)
+            with gr.TabItem("📈 Model Performance"):
+                gr.Markdown(
+                    """
+                    ### Evaluation Results on Fashion Product Dataset
+
+                    Model fine tuned on over 14k images and tested on a validation set of 1000 images.
+
+                    Images pulled from [HuggingFace Datasets](https://huggingface.co/datasets/ceyda/fashion-products-small)
+                    """
+                )
+
+                # Display uploaded evaluation charts
+                with gr.Row():
+                    gr.Image(
+                        value=str(ASSETS_PATH / "Accuracy.png"),
+                        interactive=False,
+                        show_label=False,
+                    )
+                    gr.Image(
+                        value=str(ASSETS_PATH / "Accuracy-precision-recall.png"),
+                        interactive=False,
+                        show_label=False,
+                    )
+
+                gr.Markdown(
+                    """
+                    **Key Findings:**
+                    - Qwen2.5-VL-72B-SFT achieves >95% accuracy on masterCategory
+                    - Fine-tuned model shows 18% improvement on subCategory vs base model
+                    - All models maintain >90% precision and recall on gender classification
+                    """
+                )
+
+    return demo
+
+
+if __name__ == "__main__":
+    # Launch demo
+    demo = create_demo_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+    )