Spaces:
Running
Running
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| from search import search_images_by_text, get_similar_images, search_images_by_image | |
| import requests | |
| from io import BytesIO | |
| def create_collection_url(row): | |
| base_url = "https://www.vogue.com/fashion-shows/" | |
| season = str(row["season"]).lower() | |
| year = str(row["year"]) | |
| category = str(row["category"]).lower() if pd.notna(row["category"]) and row["category"] and str(row["category"]).lower() != "nan" else None | |
| designer = str(row["designer"]).lower().replace(" ", "-") | |
| # Add city if available | |
| city = str(row["city"]).lower().replace(" ", "-") if pd.notna(row["city"]) and row["city"] and str(row["city"]).lower() != "nan" else None | |
| if pd.isna(category) or category is None or category == "nan": | |
| if city: | |
| return f"{base_url}{city}-{season}-{year}/{designer}" | |
| else: | |
| return f"{base_url}{season}-{year}/{designer}" | |
| else: | |
| if city: | |
| return f"{base_url}{city}-{season}-{year}-{category}/{designer}" | |
| else: | |
| return f"{base_url}{season}-{year}-{category}/{designer}" | |
| import requests | |
| from io import BytesIO | |
| #@st.cache_data(show_spinner="Loading FashionDB...") | |
| def load_data_hf(): | |
| # Load the Parquet file directly from Hugging Face | |
| df_url = "https://huggingface.co/datasets/traopia/vogue-runway/resolve/main/VogueRunway.parquet" | |
| df = pd.read_parquet(df_url) | |
| # Load the .npy file using requests | |
| npy_url = "https://huggingface.co/datasets/traopia/vogue-runway/resolve/main/VogueRunway_image.npy" | |
| response = requests.get(npy_url) | |
| response.raise_for_status() # Raise error if download fails | |
| embeddings = np.load(BytesIO(response.content)) | |
| df['collection'] = df.apply(create_collection_url, axis=1) | |
| return df, embeddings | |
| df, embeddings = load_data_hf() | |
| # Filter and search | |
| def filter_and_search(fashion_house, category, season, start_year, end_year, query): | |
| filtered = df.copy() | |
| if fashion_house: | |
| filtered = filtered[filtered['designer'].isin(fashion_house)] | |
| if category: | |
| filtered = filtered[filtered['category'].isin(category)] | |
| if season: | |
| filtered = filtered[filtered['season'].isin(season)] | |
| filtered = filtered[(filtered['year'] >= start_year) & (filtered['year'] <= end_year)] | |
| if query: | |
| results = search_images_by_text(query, filtered, embeddings) | |
| else: | |
| results = filtered.head(30) | |
| image_urls = results["url"].tolist() | |
| metadata = results.to_dict(orient="records") | |
| return image_urls, metadata | |
| # Display metadata and similar | |
| def show_metadata(idx, metadata): | |
| item = metadata[idx] | |
| out = "" | |
| for field in ["designer", "season", "year", "category"]: | |
| if field in item and pd.notna(item[field]): | |
| out += f"**{field.title()}**: {item[field]}\n" | |
| if 'collection' in item and pd.notna(item['collection']): | |
| out += f"\n[View Collection]({item['collection']})" | |
| return out | |
| def find_similar(idx, metadata): | |
| if not isinstance(idx, int) or idx >= len(metadata) or idx < 0: | |
| return [] # or gr.update(visible=False) | |
| key = metadata[idx]["key"] | |
| similar_df = get_similar_images(df, key, embeddings, top_k=5) | |
| return similar_df["url"].tolist(), similar_df.to_dict(orient="records") | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# 👗 FashionDB Explorer") | |
| with gr.Tabs(): | |
| # TEXT SEARCH TAB | |
| with gr.Tab("Search by Text"): | |
| with gr.Row(): | |
| fashion_house = gr.Dropdown(label="Fashion House", choices=sorted(df["designer"].dropna().unique()), multiselect=True) | |
| category = gr.Dropdown(label="Category", choices=sorted(df["category"].dropna().unique()), multiselect=True) | |
| season = gr.Dropdown(label="Season", choices=sorted(df["season"].dropna().unique()), multiselect=True) | |
| min_year = int(df['year'].min()) | |
| max_year = int(df['year'].max()) | |
| start_year = gr.Slider(label="Start Year", minimum=min_year, maximum=max_year, value=2000, step=1) | |
| end_year = gr.Slider(label="End Year", minimum=min_year, maximum=max_year, value=2024, step=1) | |
| query = gr.Textbox(label="Search by text", placeholder="e.g., pink dress") | |
| search_button = gr.Button("Search") | |
| result_gallery = gr.Gallery(label="Search Results", columns=5, height="auto") | |
| metadata_output = gr.Markdown() | |
| reference_image = gr.Image(label="Reference Image", interactive=False) | |
| similar_gallery = gr.Gallery(label="Similar Images", columns=5, height="auto") | |
| metadata_state = gr.State([]) | |
| selected_idx = gr.Number(value=0, visible=False) | |
| def handle_search(fh, cat, sea, sy, ey, q): | |
| imgs, meta = filter_and_search(fh, cat, sea, sy, ey, q) | |
| return imgs, meta, "", [], None | |
| search_button.click( | |
| handle_search, | |
| inputs=[fashion_house, category, season, start_year, end_year, query], | |
| outputs=[result_gallery, metadata_state, metadata_output, similar_gallery, reference_image] | |
| ) | |
| def handle_click(evt: gr.SelectData, metadata): | |
| idx = evt.index | |
| md = show_metadata(idx, metadata) | |
| img_path = metadata[idx]["url"] | |
| return idx, md, img_path | |
| result_gallery.select( | |
| handle_click, | |
| inputs=[metadata_state], | |
| outputs=[selected_idx, metadata_output, reference_image] | |
| ) | |
| def show_similar(idx, metadata): | |
| if idx is None or not str(idx).isdigit(): | |
| return [], [] | |
| return find_similar(int(idx), metadata) | |
| similar_metadata_state = gr.State() | |
| similar_metadata_output = gr.Markdown() | |
| show_similar_button = gr.Button("Show Similar Images") | |
| show_similar_button.click( | |
| show_similar, | |
| inputs=[selected_idx, metadata_state], | |
| outputs=[similar_gallery, similar_metadata_state] | |
| ) | |
| def handle_similar_click(evt: gr.SelectData, metadata): | |
| idx = evt.index | |
| md = show_metadata(idx, metadata) | |
| img_path = metadata[idx]["url"] | |
| return idx, md, img_path | |
| similar_gallery.select( | |
| handle_similar_click, | |
| inputs=[similar_metadata_state], | |
| outputs=[selected_idx, similar_metadata_output, reference_image] | |
| ) | |
| # IMAGE SEARCH TAB | |
| with gr.Tab("Search by Image"): | |
| with gr.Row(): | |
| fashion_house_img = gr.Dropdown(label="Fashion House", choices=sorted(df["designer"].dropna().unique()), multiselect=True) | |
| category_img = gr.Dropdown(label="Category", choices=sorted(df["category"].dropna().unique()), multiselect=True) | |
| season_img = gr.Dropdown(label="Season", choices=sorted(df["season"].dropna().unique()), multiselect=True) | |
| start_year_img = gr.Slider(label="Start Year", minimum=min_year, maximum=max_year, value=2000, step=1) | |
| end_year_img = gr.Slider(label="End Year", minimum=min_year, maximum=max_year, value=2024, step=1) | |
| uploaded_image = gr.Image(label="Upload an image", type="pil") | |
| search_by_image_button = gr.Button("Search by Image") | |
| uploaded_result_gallery = gr.Gallery(label="Search Results by Image", columns=5, height="auto") | |
| uploaded_metadata_state = gr.State([]) | |
| uploaded_metadata_output = gr.Markdown() | |
| uploaded_reference_image = gr.Image(label="Reference Image", interactive=False) | |
| def handle_search_by_image(image, fh, cat, sea, sy, ey): | |
| if image is None: | |
| return [], "Please upload an image first.", None | |
| # Apply filters | |
| filtered_df = df.copy() | |
| if fh: filtered_df = filtered_df[filtered_df["designer"].isin(fh)] | |
| if cat: filtered_df = filtered_df[filtered_df["category"].isin(cat)] | |
| if sea: filtered_df = filtered_df[filtered_df["season"].isin(sea)] | |
| filtered_df = filtered_df[(filtered_df["year"] >= sy) & (filtered_df["year"] <= ey)] | |
| results_df = search_images_by_image(image, filtered_df, embeddings) | |
| images = results_df['url'].tolist() | |
| metadata = results_df.to_dict(orient="records") | |
| return images, metadata, "" | |
| search_by_image_button.click( | |
| handle_search_by_image, | |
| inputs=[uploaded_image, fashion_house_img, category_img, season_img, start_year_img, end_year_img], | |
| outputs=[uploaded_result_gallery, uploaded_metadata_state, uploaded_metadata_output] | |
| ) | |
| uploaded_selected_idx = gr.Number(visible=False) | |
| def handle_uploaded_click(evt: gr.SelectData, metadata): | |
| idx = evt.index | |
| md = show_metadata(idx, metadata) | |
| img_path = metadata[idx]["url"] | |
| return idx, md, img_path | |
| uploaded_result_gallery.select( | |
| handle_uploaded_click, | |
| inputs=[uploaded_metadata_state], | |
| outputs=[uploaded_selected_idx, uploaded_metadata_output, uploaded_reference_image] | |
| ) | |
| # SIMILAR IMAGE SEARCH FOR IMAGE TAB | |
| uploaded_similar_gallery = gr.Gallery(label="Similar Images", columns=5, height="auto") | |
| uploaded_similar_metadata_state = gr.State([]) | |
| uploaded_similar_metadata_output = gr.Markdown() | |
| uploaded_show_similar_button = gr.Button("Show Similar Images") | |
| def show_similar_uploaded(idx, metadata): | |
| if idx is None or not str(idx).isdigit(): | |
| return [], [] | |
| return find_similar(int(idx), metadata) | |
| uploaded_show_similar_button.click( | |
| show_similar_uploaded, | |
| inputs=[uploaded_selected_idx, uploaded_metadata_state], | |
| outputs=[uploaded_similar_gallery, uploaded_similar_metadata_state] | |
| ) | |
| def handle_uploaded_similar_click(evt: gr.SelectData, metadata): | |
| idx = evt.index | |
| md = show_metadata(idx, metadata) | |
| img_path = metadata[idx]["url"] | |
| return idx, md, img_path | |
| uploaded_similar_gallery.select( | |
| handle_uploaded_similar_click, | |
| inputs=[uploaded_similar_metadata_state], | |
| outputs=[uploaded_selected_idx, uploaded_similar_metadata_output, uploaded_reference_image] | |
| ) | |
| uploaded_back_button = gr.Button("Back to Initial Uploaded Search") | |
| def back_to_uploaded_home(): | |
| return [], "", None | |
| uploaded_back_button.click( | |
| back_to_uploaded_home, | |
| outputs=[uploaded_similar_gallery, uploaded_similar_metadata_output, uploaded_reference_image] | |
| ) | |
| with gr.Tab("Query on FashionDB"): | |
| with gr.Row(): | |
| gr.Markdown( | |
| "### 🔗 Query FashionDB SPARQL Endpoint\n" | |
| "[Click here to open the SPARQL endpoint](https://fashionwiki.wikibase.cloud/query/)", | |
| elem_id="sparql-link" | |
| ) | |
| back_button = gr.Button("Back to Home") | |
| def back_to_home(): | |
| return [], "", None # clear similar_gallery, metadata_output, reference image | |
| back_button.click( | |
| back_to_home, | |
| outputs=[similar_gallery, similar_metadata_output, reference_image] | |
| ) | |
| demo.launch() |