diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..25392875cbdfb502253a041a89271bcc8f3f2cf6 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,40 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0006_00981_MesaTask_Towards_Task-Driven_Tabletop_Scene_Generation_via_3D_Spatial_Reasoning__ddce4bdb68a1689579a491b5a31349db83e5046fbb5424a45dc0883d4115e7d5.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0007_01003_OmniSync_Towards_Universal_Lip_Synchronization_via_Diffusion_Transformers__28d606ccd79ed54496343219767701efb0f445058d39887c1cf629a800942f77.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0011_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__b501bcad7830654e421726b37ea0d89207d68c72f0f6aa9179fec65e0c71b205.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0014_01659_G-Memory_Tracing_Hierarchical_Memory_for_Multi-Agent_Systems__48772f699bccd9ecf7285d9f2c4af85d34d60b7ee6b2cbd681278611869db12b.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0019_02373_MDReID_Modality-Decoupled_Learning_for_Any-to-Any_Multi-Modal_Object_Re-Identification__517a2ed3f7dd16e048d526da7807ac8b1b73cdb062b79021b7047dd0b467ba9a.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0020_03077_Toward_Relative_Positional_Encoding_in_Spiking_Transformers__bdb178031ec8d263c3a5388d900e974b8ce39ae5759a6611f688a57e22173fa5.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0038_06527_Robust_Graph_Condensation_via_Classification_Complexity_Mitigation__dedb33c198673910da24a5a2a5794a8228afce42d7b46ff594dab0cac9ee61e0.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0040_06606_Disentangled_Concepts_Speak_Louder_Than_Words_Explainable_Video_Action_Recognition__fe96a76b160d3861e188cfe5511fee2d4f07eada1ebf92ade017048a3362d5b8.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0041_07858_HYPERION_Fine-Grained_Hypersphere_Alignment_for_Robust_Federated_Graph_Learning__be29a99497ec2dd4d3a8993ce3edc85c87505a1cabfadc2df234b7e326633ebc.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0043_08772_RepoMaster_Autonomous_Exploration_and_Understanding_of_GitHub_Repositories_for_Complex_Task_Solving__c5102f7309c920d53df2307418ef99304d083aa3f54140e3fa2e55c6b259378b.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0046_09315_Personalized_Decision_Modeling_Utility_Optimization_or_Textualized-Symbolic_Reasoning__56df140d7973f4f1a6286c7cebec84068dc6828711cea2e455416a0d9d381a99.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0048_09629_4DGT_Learning_a_4D_Gaussian_Transformer_Using_Real-World_Monocular_Videos__64516a621163af326843f0152bd0cdb8f798d2df70242271249a95e572c7a300.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0052_10520_TrajMamba_An_Efficient_and_Semantic-rich_Vehicle_Trajectory_Pre-training_Model__02d2a7b7aa1ad60cce35445c46fdcb453afa273d8a170ce0abe33ab2c8c6f245.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0058_13240_A_machine_learning_approach_that_beats_Rubiks_cubes__aec92a7999c868664250d8e9aad60b03dbacabd440355bec73af28c512c9d18a.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0060_14126_Deno-IF_Unsupervised_Noisy_Visible_and_Infrared_Image_Fusion_Method__685d5064d5b82a4e2e38976afb4b02e3359ccff154e8231646e76cb16970b7a0.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0070_15841_Co-Reinforcement_Learning_for_Unified_Multimodal_Understanding_and_Generation__8d1bdeb48a8ecdf31ace6493caea90ec34e8e10428d5b91397cd5531c2b33b09.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0074_16584_IA-GGAD_Zero-shot_Generalist_Graph_Anomaly_Detection_via_Invariant_and_Affinity_Learning__2be0842b017b1925d07b25f0276d02ffabc8a00fe4e73cc930b0ee0096fcfd40.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0079_19455_Wide-Horizon_Thinking_and_Simulation-Based_Evaluation_for_Real-World_LLM_Planning_with_Multifaceted_Constraints__198c85b432b1ddbf1afc76ab8c98e057973c4763acbaa0f16a4da51d97460935.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0087_22755_Breaking_the_Batch_Barrier_B3_of_Contrastive_Learning_via_Smart_Batch_Mining__588e6566b5416ccc18d5f5733612cbc3caa0c11fe2e3bc5c57c32c88a9ec2e41.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0095_26919_FUDOKI_Discrete_Flow-based_Unified_Understanding_and_Generation_via_Kinetic-Optimal_Velocities__9c0a452656594ea3134b9cdcb16988663e9015013c42419254bc35661139b69f.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0096_26975_LogicTree_Improving_Complex_Reasoning_of_LLMs_via_Instantiated_Multi-step_Synthetic_Logical_Data__75918e90d782aa4c0011abbf0fe69a93e2595315a84e5dd3ba23b1cddfb672b5.jpg filter=lfs diff=lfs merge=lfs -text +data/spotlight_reference_images/ref_0098_27155_DexFlyWheel_A_Scalable_and_Self-improving_Data_Generation_Framework_for_Dexterous_Manipulation__6cb5d9f8f05d11ff6e6bf4f69015de5ad79051d577633793092cf0b753f0d1aa.jpg filter=lfs diff=lfs merge=lfs -text +examples/basic_example_iter1_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/basic_example_iter2_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/basic_example_iter3_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/neurips_refs_iter1_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/neurips_refs_iter2_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/neurips_refs_iter3_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/ddpm_iter1_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/ddpm_iter2_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/ddpm_iter3_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/resnet_iter1_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/resnet_iter2_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/resnet_iter3_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/transformer_iter1_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/transformer_iter2_0.jpg filter=lfs diff=lfs merge=lfs -text +examples/readme/transformer_iter3_0.jpg filter=lfs diff=lfs merge=lfs -text diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ca3b8b266b8e1ce96aefd8205f90cf9faa65554d --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +FROM python:3.10-slim + +# System deps +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Create non-root user (HF Spaces requirement) +RUN useradd -m -u 1000 user +ENV HOME=/home/user \ + PATH=/home/user/.local/bin:$PATH + +WORKDIR /app + +# Install Python deps first (cache layer) +COPY requirements.txt . +RUN pip install --no-cache-dir --upgrade pip && \ + pip install --no-cache-dir -r requirements.txt + +# Copy app code +COPY --chown=user . . + +USER user + +EXPOSE 7860 + +CMD ["python", "app.py"] diff --git a/README.md b/README.md index d9b1de7733fce83dc27358899889bfb62a8d9016..50704b2280678306c0a66e1779782255b9b9fd86 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,11 @@ --- title: PaperBanana -emoji: 🌍 -colorFrom: purple +emoji: 🍌 +colorFrom: yellow colorTo: yellow sdk: docker -pinned: false +app_file: app.py +pinned: true +license: mit +short_description: Methodology text to architecture diagrams --- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/aesthetic_guidelines.py b/aesthetic_guidelines.py new file mode 100644 index 0000000000000000000000000000000000000000..09f4eaf85ba19d9b1d001604f11844fd5fc6aa0c --- /dev/null +++ b/aesthetic_guidelines.py @@ -0,0 +1,64 @@ +""" +Aesthetic Guidelines (G) for academic illustration styling. +Based on Appendix F of the PaperBanana paper. +""" + +AESTHETIC_GUIDELINE = """ +# Academic Illustration Style Guide (NeurIPS Style) + +## Color Palette +- **Overall Aesthetic:** Soft Tech & Scientific Pastels ("NeurIPS Look") +- **Background Colors:** Cream (#FFF8E7), Pale Blue (#E3F2FD), Mint (#E8F5E9) +- **Accent Colors:** + - Soft Blue (#64B5F6) for primary processes + - Soft Orange (#FFB74D) for secondary/iterative processes + - Soft Purple (#9575CD) for highlighting key components + - Soft Green (#81C784) for success/outputs +- **Use color to group logical components** + +## Shapes and Components +- **Process Boxes:** Rounded rectangles with subtle shadows +- **Data/Tensors:** 3D stacks or layered rectangles +- **Databases/Storage:** Cylinders or drum shapes +- **Agents/Models:** Robot or brain icons with labels +- **Inputs/Outputs:** Parallelograms or cloud shapes + +## Lines and Arrows +- **Network/Architecture Diagrams:** Orthogonal/Elbow connectors +- **Logic Flow:** Curved arrows for feedback loops +- **Data Flow:** Straight arrows with clear directionality +- **Arrow Styles:** Solid for primary flow, dashed for optional/conditional + +## Typography +- **Labels:** Sans-serif fonts (Arial, Roboto, Helvetica) +- **Mathematical Variables:** Serif Italic (Times New Roman) - use LaTeX notation (e.g., $P$, $P^*$) +- **Font Sizes:** + - Main labels: 12-14pt + - Subscript/technical: 10pt + - Section headers: 16pt bold + +## Layout Principles +- **Hierarchy:** Left-to-right or top-to-bottom flow +- **Grouping:** Use containers/boxes with subtle backgrounds to group related components +- **Spacing:** Generous whitespace, consistent padding +- **Alignment:** Grid-based layout, aligned elements +- **Balance:** Visual weight distributed evenly + +## Technical Details +- **Line Weight:** 1.5-2pt for main elements, 1pt for details +- **Corner Radius:** 8-12px for rounded rectangles +- **Shadow:** Subtle drop shadow (opacity 10-20%) +- **Icons:** Simple, consistent style throughout + +## Diagram-Specific Guidelines +### Architecture Diagrams +- Show clear input β†’ process β†’ output flow +- Use containers to separate phases/stages +- Include feedback loops where applicable + +### Methodology Diagrams +- Emphasize the pipeline structure +- Show agent interactions clearly +- Use consistent icons for similar components +- Annotate with mathematical notation where relevant +""" diff --git a/agents/__init__.py b/agents/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8df11f5720d0978cc53e02e5e59ebd2cf96174d2 --- /dev/null +++ b/agents/__init__.py @@ -0,0 +1,17 @@ +""" +Agents package for PaperBanana framework. +""" + +from .retriever import RetrieverAgent +from .planner import PlannerAgent +from .stylist import StylistAgent +from .visualizer import VisualizerAgent +from .critic import CriticAgent + +__all__ = [ + 'RetrieverAgent', + 'PlannerAgent', + 'StylistAgent', + 'VisualizerAgent', + 'CriticAgent' +] diff --git a/agents/critic.py b/agents/critic.py new file mode 100644 index 0000000000000000000000000000000000000000..ed4ead1210d8333a61c59b0d5e990b9f4853af90 --- /dev/null +++ b/agents/critic.py @@ -0,0 +1,234 @@ +""" +Critic Agent for PaperBanana framework. + +Forms closed-loop refinement mechanism by identifying factual misalignments +or visual glitches and providing feedback for iterative improvement. +""" +import os +from typing import Dict, List +from google import genai +from google.genai import types +import config + + +class CriticAgent: + """ + Critic Agent: Provides iterative feedback for refinement. + + Identifies factual misalignments, visual glitches, and areas for improvement + in generated illustrations, enabling closed-loop refinement. + """ + + def __init__(self): + """Initialize Critic Agent.""" + self.client = genai.Client(api_key=config.GEMINI_API_KEY) + self.model = config.VLM_MODEL + + def critique(self, + methodology_text: str, + caption: str, + current_description: str, + generated_image_path: str = None, + iteration: int = 1) -> Dict[str, any]: + """ + Provide critique and feedback on current illustration. + + Args: + methodology_text: Original methodology description + caption: Target diagram caption + current_description: Current textual description + generated_image_path: Path to generated image (if available) + iteration: Current iteration number + + Returns: + Dictionary containing: + - 'feedback': Textual feedback + - 'issues': List of identified issues + - 'suggestions': List of improvement suggestions + - 'should_continue': Boolean indicating if refinement should continue + """ + prompt = self._create_critique_prompt( + methodology_text, + caption, + current_description, + iteration + ) + + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=prompt)] + ) + ] + + # If we have an image, we could add it to the critique (future enhancement) + # For now, we critique based on the description + + generate_config = types.GenerateContentConfig( + thinking_config=types.ThinkingConfig( + thinking_level=config.THINKING_LEVEL + ) + ) + + critique_text = "" + for chunk in self.client.models.generate_content_stream( + model=self.model, + contents=contents, + config=generate_config + ): + critique_text += chunk.text + + # Parse critique into structured feedback + result = self._parse_critique(critique_text, iteration) + + return result + + def _create_critique_prompt(self, + methodology_text: str, + caption: str, + current_description: str, + iteration: int) -> str: + """Create prompt for critique generation.""" + prompt = f"""You are an expert reviewer of academic illustrations, specializing in methodology diagrams. + +Your task is to critically evaluate a textual description for an academic diagram and provide constructive feedback. + +ORIGINAL METHODOLOGY: +{methodology_text} + +TARGET CAPTION: +{caption} + +CURRENT ILLUSTRATION DESCRIPTION (Iteration {iteration}): +{current_description} + +EVALUATION CRITERIA: + +1. **Faithfulness**: Does the description accurately represent all key aspects of the methodology? + - Are all important components mentioned? + - Is the flow/logic correctly represented? + - Are there any factual errors or misrepresentations? + +2. **Conciseness**: Is the description appropriately detailed without being cluttered? + - Is information density appropriate? + - Are there redundant elements? + - Is anything unnecessarily complex? + +3. **Readability**: Will the resulting diagram be easy to understand? + - Is the layout logical? + - Are labels clear and informative? + - Is visual hierarchy appropriate? + +4. **Aesthetics**: Does the description specify professional visual design? + - Are colors, shapes, and typography well-defined? + - Is there visual consistency? + - Does it match academic publication standards? + +YOUR TASK: +Provide a structured critique covering: + +ISSUES FOUND: +- List specific problems (e.g., "Missing connection between X and Y") +- Rate severity: CRITICAL, MAJOR, or MINOR + +SUGGESTIONS FOR IMPROVEMENT: +- Provide concrete, actionable suggestions +- Prioritize by impact + +OVERALL ASSESSMENT: +- Is this ready for visualization, or does it need refinement? +- If iteration {iteration} < 3, should we continue refining? + +OUTPUT FORMAT: +Structure your response as: + +ISSUES: +1. [SEVERITY] Issue description +2. [SEVERITY] Issue description +... + +SUGGESTIONS: +1. Specific suggestion +2. Specific suggestion +... + +DECISION: [READY / NEEDS_REFINEMENT] +REASONING: Brief explanation of the decision +""" + return prompt + + def _parse_critique(self, critique_text: str, iteration: int) -> Dict: + """Parse critique text into structured format.""" + issues = [] + suggestions = [] + should_continue = True + + # Simple parsing - look for key sections + lines = critique_text.split('\n') + current_section = None + + for line in lines: + line_upper = line.upper().strip() + + if 'ISSUES:' in line_upper: + current_section = 'issues' + continue + elif 'SUGGESTIONS:' in line_upper or 'SUGGESTION' in line_upper: + current_section = 'suggestions' + continue + elif 'DECISION:' in line_upper: + current_section = 'decision' + if 'READY' in line_upper and 'NEEDS_REFINEMENT' not in line_upper: + should_continue = False + continue + + # Parse content + line = line.strip() + if not line or line.startswith('#'): + continue + + if current_section == 'issues' and (line.startswith('-') or line[0].isdigit()): + issues.append(line.lstrip('-').lstrip('0123456789.').strip()) + elif current_section == 'suggestions' and (line.startswith('-') or line[0].isdigit()): + suggestions.append(line.lstrip('-').lstrip('0123456789.').strip()) + + # Don't continue past max iterations + if iteration >= config.MAX_REFINEMENT_ITERATIONS: + should_continue = False + + return { + 'feedback': critique_text, + 'issues': issues, + 'suggestions': suggestions, + 'should_continue': should_continue + } + + def generate_refinement_prompt(self, + original_description: str, + critique: Dict) -> str: + """ + Generate prompt for refinement based on critique. + + Args: + original_description: Current description + critique: Critique dictionary from critique() + + Returns: + Prompt for Planner to refine the description + """ + issues_text = "\n".join([f"- {issue}" for issue in critique['issues']]) + suggestions_text = "\n".join([f"- {sug}" for sug in critique['suggestions']]) + + refinement_prompt = f"""CURRENT DESCRIPTION: +{original_description} + +IDENTIFIED ISSUES: +{issues_text} + +SUGGESTIONS FOR IMPROVEMENT: +{suggestions_text} + +Please revise the description to address these issues and incorporate the suggestions. +Maintain all correct elements while fixing the identified problems. +""" + return refinement_prompt diff --git a/agents/planner.py b/agents/planner.py new file mode 100644 index 0000000000000000000000000000000000000000..c12e7a8d2b69a99f1819ab280f5d682d0056a042 --- /dev/null +++ b/agents/planner.py @@ -0,0 +1,117 @@ +""" +Planner Agent for PaperBanana framework. + +Serves as the cognitive core. Translates unstructured methodology data +into comprehensive textual description of the target illustration. +""" +import os +from typing import List, Dict, Any +from google import genai +from google.genai import types +import config + + +class PlannerAgent: + """ + Planner Agent: Translates methodology into comprehensive illustration description. + + The cognitive core that interprets source context S and communicative intent C, + then produces detailed textual description P of the target illustration. + """ + + def __init__(self): + """Initialize Planner Agent.""" + self.client = genai.Client(api_key=config.GEMINI_API_KEY) + self.model = config.VLM_MODEL + + def plan(self, + methodology_text: str, + caption: str, + reference_examples: List[Dict[str, Any]] = None) -> str: + """ + Generate comprehensive textual description of target illustration. + + Args: + methodology_text: Source methodology description (S) + caption: Diagram caption (part of C) + reference_examples: Retrieved reference examples (E) + + Returns: + Detailed textual description P of the illustration + """ + prompt = self._create_planning_prompt(methodology_text, caption, reference_examples) + + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=prompt)] + ) + ] + + generate_config = types.GenerateContentConfig( + thinking_config=types.ThinkingConfig( + thinking_level=config.THINKING_LEVEL + ) + ) + + description = "" + for chunk in self.client.models.generate_content_stream( + model=self.model, + contents=contents, + config=generate_config + ): + description += chunk.text + + return description.strip() + + def _create_planning_prompt(self, + methodology_text: str, + caption: str, + reference_examples: List[Dict[str, Any]] = None) -> str: + """Create prompt for generating illustration description.""" + + # Include reference examples if available + reference_context = "" + if reference_examples: + reference_context = "\n\nREFERENCE EXAMPLES (for inspiration):\n" + for i, ref in enumerate(reference_examples[:3], 1): # Use top 3 + reference_context += f"\nExample {i}:\n" + reference_context += f"Domain: {ref.get('domain', 'N/A')}\n" + reference_context += f"Type: {ref.get('diagram_type', 'N/A')}\n" + reference_context += f"Description: {ref.get('description', 'N/A')}\n" + + prompt = f"""You are an expert at designing academic methodology diagrams for scientific publications. + +Your task is to create a COMPREHENSIVE and DETAILED textual description of an illustration that would +effectively visualize the given methodology. This description will be used to generate the actual diagram. + +METHODOLOGY TO VISUALIZE: +{methodology_text} + +TARGET DIAGRAM CAPTION: +{caption} +{reference_context} + +REQUIREMENTS: +1. **Layout Structure**: Specify the overall layout (left-to-right, top-to-bottom, circular, etc.) +2. **Components**: List all visual elements needed (boxes, arrows, icons, labels, etc.) +3. **Content**: What text/symbols should appear in each component +4. **Connections**: How components connect (arrows, lines, groupings) +5. **Hierarchy**: Which elements are primary vs secondary +6. **Grouping**: How to group related components (containers, background colors) +7. **Flow**: The logical flow of information through the diagram +8. **Key Details**: Important technical details, equations, or annotations + +IMPORTANT GUIDELINES: +- Be specific about spatial relationships and positioning +- Describe the logical flow clearly (input β†’ process β†’ output) +- Include any mathematical notation or technical terminology +- Consider the target audience (academic researchers) +- Focus on clarity and information density +- Think about how this supports the paper's narrative + +OUTPUT FORMAT: +Provide a detailed paragraph-form description that covers all aspects above. +Be thorough - this description should be sufficient for someone to create the diagram without seeing the original methodology. +""" + return prompt diff --git a/agents/retriever.py b/agents/retriever.py new file mode 100644 index 0000000000000000000000000000000000000000..d5f27e1c797ac4e8e536b96d763573642bbed075 --- /dev/null +++ b/agents/retriever.py @@ -0,0 +1,151 @@ +""" +Retriever Agent for PaperBanana framework. + +Identifies the N most relevant examples from a reference set using VLM ranking. +Matches based on research domain and diagram type. +""" +import os +from typing import List, Dict, Any +from google import genai +from google.genai import types +import config + + +class RetrieverAgent: + """ + Retriever Agent: Identifies relevant reference examples from a fixed reference set. + + Uses generative retrieval approach where VLM ranks candidates by matching + research domain and diagram type. + """ + + def __init__(self, reference_set: List[Dict[str, Any]] = None): + """ + Initialize Retriever Agent. + + Args: + reference_set: List of reference examples with metadata + Each example should have: { + 'id': str, + 'domain': str, + 'diagram_type': str, + 'description': str, + 'image_path': str (optional) + } + """ + self.client = genai.Client(api_key=config.GEMINI_API_KEY) + self.model = config.VLM_MODEL + self.reference_set = reference_set or [] + + def retrieve(self, + methodology_text: str, + caption: str, + n: int = config.NUM_REFERENCE_EXAMPLES) -> List[Dict[str, Any]]: + """ + Retrieve the N most relevant reference examples. + + Args: + methodology_text: Source methodology description + caption: Target diagram caption + n: Number of examples to retrieve + + Returns: + List of N most relevant reference examples + """ + if not self.reference_set: + print("Warning: No reference set provided. Skipping retrieval.") + return [] + + # Create retrieval prompt + prompt = self._create_retrieval_prompt(methodology_text, caption, n) + + # Query VLM for ranking + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=prompt)] + ) + ] + + generate_config = types.GenerateContentConfig( + thinking_config=types.ThinkingConfig( + thinking_level=config.THINKING_LEVEL + ) + ) + + response_text = "" + for chunk in self.client.models.generate_content_stream( + model=self.model, + contents=contents, + config=generate_config + ): + response_text += chunk.text + + # Parse the response to extract selected example IDs + selected_examples = self._parse_retrieval_response(response_text, n) + + return selected_examples + + def _create_retrieval_prompt(self, methodology_text: str, caption: str, n: int) -> str: + """Create prompt for retrieving relevant examples.""" + # Create a summary of available references + reference_summary = "\n".join([ + f"ID: {ref['id']}\nDomain: {ref['domain']}\nType: {ref['diagram_type']}\nDescription: {ref['description']}\n" + for ref in self.reference_set + ]) + + prompt = f"""You are an expert at identifying relevant academic illustration examples. + +Given a methodology description and diagram caption, select the {n} most relevant reference examples +from the provided set. Consider: +1. Research domain similarity (e.g., NLP, Computer Vision, Reinforcement Learning) +2. Diagram type similarity (e.g., architecture diagram, flowchart, pipeline) +3. Conceptual similarity in the methodology + +METHODOLOGY: +{methodology_text} + +TARGET CAPTION: +{caption} + +AVAILABLE REFERENCE EXAMPLES: +{reference_summary} + +OUTPUT FORMAT: +Return only the IDs of the {n} most relevant examples, one per line, ranked from most to least relevant. +Example output: +ref_001 +ref_005 +ref_012 +""" + return prompt + + def _parse_retrieval_response(self, response_text: str, n: int) -> List[Dict[str, Any]]: + """Parse VLM response to extract selected examples.""" + # Extract IDs from response + lines = response_text.strip().split('\n') + selected_ids = [] + + for line in lines: + line = line.strip() + # Look for reference IDs + for ref in self.reference_set: + if ref['id'] in line: + selected_ids.append(ref['id']) + break + if len(selected_ids) >= n: + break + + # Get full reference objects + selected_examples = [] + for ref_id in selected_ids: + for ref in self.reference_set: + if ref['id'] == ref_id: + selected_examples.append(ref) + break + + # If we didn't get enough, just take the first n + if len(selected_examples) < n: + selected_examples = self.reference_set[:n] + + return selected_examples[:n] diff --git a/agents/stylist.py b/agents/stylist.py new file mode 100644 index 0000000000000000000000000000000000000000..0aef45afe2ded93f20858566495a9c11db4602cb --- /dev/null +++ b/agents/stylist.py @@ -0,0 +1,104 @@ +""" +Stylist Agent for PaperBanana framework. + +Acts as a design consultant. Uses automatically synthesized aesthetic +guidelines to refine initial description into stylistically optimized version. +""" +import os +from google import genai +from google.genai import types +import config +from aesthetic_guidelines import AESTHETIC_GUIDELINE + + +class StylistAgent: + """ + Stylist Agent: Refines illustration descriptions using aesthetic guidelines. + + Takes initial description P and enhances it with style guidance G + to produce stylistically optimized description P*. + """ + + def __init__(self, custom_guidelines: str = None): + """ + Initialize Stylist Agent. + + Args: + custom_guidelines: Optional custom aesthetic guidelines. + If None, uses default NeurIPS-style guidelines. + """ + self.client = genai.Client(api_key=config.GEMINI_API_KEY) + self.model = config.VLM_MODEL + self.guidelines = custom_guidelines or AESTHETIC_GUIDELINE + + def refine(self, initial_description: str) -> str: + """ + Refine initial description with aesthetic styling. + + Args: + initial_description: Initial textual description P + + Returns: + Stylistically optimized description P* + """ + prompt = self._create_styling_prompt(initial_description) + + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=prompt)] + ) + ] + + generate_config = types.GenerateContentConfig( + thinking_config=types.ThinkingConfig( + thinking_level=config.THINKING_LEVEL + ) + ) + + refined_description = "" + for chunk in self.client.models.generate_content_stream( + model=self.model, + contents=contents, + config=generate_config + ): + refined_description += chunk.text + + return refined_description.strip() + + def _create_styling_prompt(self, initial_description: str) -> str: + """Create prompt for aesthetic refinement.""" + prompt = f"""You are an expert design consultant specializing in academic publication illustrations. + +Your task is to take an initial diagram description and enhance it with specific aesthetic and design details +to create a polished, publication-ready illustration that follows academic standards. + +INITIAL DESCRIPTION: +{initial_description} + +AESTHETIC GUIDELINES TO FOLLOW: +{self.guidelines} + +YOUR TASK: +Refine the initial description by adding specific visual design details: + +1. **Color Specifications**: Add specific color choices from the palette (e.g., "soft blue #64B5F6 for the main process boxes") +2. **Shape Details**: Specify exact shapes and their styling (e.g., "rounded rectangles with 10px radius and subtle shadow") +3. **Typography**: Define font choices for different text elements +4. **Visual Hierarchy**: Enhance descriptions of size, weight, and emphasis relationships +5. **Spacing & Layout**: Add details about padding, margins, and alignment +6. **Professional Polish**: Include finishing touches like shadows, borders, gradients + +IMPORTANT: +- Preserve ALL content and structural information from the initial description +- Add aesthetic details WITHOUT changing the fundamental design or information flow +- Be specific with measurements, colors (hex codes), and styling parameters +- Ensure the result maintains academic professionalism and clarity +- The output should be suitable for direct input to an image generation model + +OUTPUT FORMAT: +Provide the enhanced description as a detailed, flowing paragraph that seamlessly integrates +the original content with the aesthetic specifications. Make it vivid and precise enough that +an image generation model can render it accurately. +""" + return prompt diff --git a/agents/visualizer.py b/agents/visualizer.py new file mode 100644 index 0000000000000000000000000000000000000000..bdc83ba4bd5d485a437a8e40895fe1bedfea73a7 --- /dev/null +++ b/agents/visualizer.py @@ -0,0 +1,199 @@ +""" +Visualizer Agent for PaperBanana framework. + +Renders academic illustrations using image generation models. +Supports both diagram generation and statistical plot generation. +""" +import os +import mimetypes +from typing import Optional +from google import genai +from google.genai import types +import config +from utils import save_binary_file + + +class VisualizerAgent: + """ + Visualizer Agent: Renders illustrations from textual descriptions. + + Supports two modes: + 1. Diagram mode: Uses image generation model (Nano-Banana-Pro / Gemini Image) + 2. Plot mode: Generates Python Matplotlib code for statistical plots + """ + + def __init__(self, mode: str = "diagram"): + """ + Initialize Visualizer Agent. + + Args: + mode: Generation mode - "diagram" or "plot" + """ + self.client = genai.Client(api_key=config.GEMINI_API_KEY) + self.mode = mode + + if mode == "diagram": + self.model = config.IMAGE_MODEL + elif mode == "plot": + self.model = config.VLM_MODEL # Use VLM for code generation + else: + raise ValueError(f"Invalid mode: {mode}. Use 'diagram' or 'plot'") + + def visualize(self, + description: str, + output_path: str = "output", + data: dict = None) -> str: + """ + Generate visualization from description. + + Args: + description: Textual description of the illustration + output_path: Base path for output file (without extension) + data: Optional data dict for plot mode + + Returns: + Path to generated image file or code file + """ + if self.mode == "diagram": + return self._generate_diagram(description, output_path) + elif self.mode == "plot": + return self._generate_plot(description, output_path, data) + + def _generate_diagram(self, description: str, output_path: str) -> str: + """ + Generate diagram image using image generation model. + + Args: + description: Detailed visual description + output_path: Base path for output file + + Returns: + Path to generated image + """ + # Create prompt for image generation + prompt = f"""Generate a high-quality academic methodology diagram with the following specifications: + +{description} + +Requirements: +- Professional academic publication quality +- Clear, readable text and labels +- Consistent styling throughout +- Appropriate use of colors and shapes +- Publication-ready resolution +""" + + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=prompt)] + ) + ] + + generate_config = types.GenerateContentConfig( + response_modalities=["IMAGE", "TEXT"], + image_config=types.ImageConfig( + image_size=config.IMAGE_SIZE + ) + ) + + file_index = 0 + saved_path = None + + for chunk in self.client.models.generate_content_stream( + model=self.model, + contents=contents, + config=generate_config + ): + if (chunk.candidates is None or + chunk.candidates[0].content is None or + chunk.candidates[0].content.parts is None): + continue + + # Check for inline image data + part = chunk.candidates[0].content.parts[0] + if part.inline_data and part.inline_data.data: + inline_data = part.inline_data + data_buffer = inline_data.data + file_extension = mimetypes.guess_extension(inline_data.mime_type) + + if file_extension: + file_name = f"{output_path}_{file_index}{file_extension}" + saved_path = save_binary_file(file_name, data_buffer) + file_index += 1 + else: + # Print any text output + if chunk.text: + print(chunk.text) + + return saved_path or f"{output_path}_0.png" + + def _generate_plot(self, description: str, output_path: str, data: dict = None) -> str: + """ + Generate statistical plot by creating Matplotlib code. + + Args: + description: Description of desired plot + output_path: Base path for output code file + data: Optional data dictionary + + Returns: + Path to generated Python code file + """ + data_context = "" + if data: + data_context = f"\n\nDATA PROVIDED:\n{str(data)}\n" + + prompt = f"""You are an expert at creating publication-quality statistical plots using Matplotlib. + +Generate complete, executable Python code using Matplotlib to create the following plot: + +{description} +{data_context} + +Requirements: +1. Use professional academic styling (seaborn-paper style or similar) +2. Include clear axis labels with units +3. Add legend if multiple series +4. Use appropriate colors and markers +5. Set figure size for publication (e.g., 6x4 inches) +6. Save as high-resolution PNG (300 dpi minimum) +7. Include error bars if applicable +8. Follow best practices for data visualization + +OUTPUT FORMAT: +Provide ONLY the complete Python code, ready to execute. +Start with necessary imports and end with plt.savefig(). +Do not include any explanations outside the code comments. +""" + + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=prompt)] + ) + ] + + generate_config = types.GenerateContentConfig( + thinking_config=types.ThinkingConfig( + thinking_level="MEDIUM" + ) + ) + + code = "" + for chunk in self.client.models.generate_content_stream( + model=self.model, + contents=contents, + config=generate_config + ): + code += chunk.text + + # Save code to file + code_file = f"{output_path}.py" + with open(code_file, 'w') as f: + f.write(code.strip()) + + print(f"Plot code saved to: {code_file}") + print("Run the code to generate the plot image.") + + return code_file diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..f52866340029a98af1f35e878e743f41160d084e --- /dev/null +++ b/app.py @@ -0,0 +1,283 @@ +""" +PaperBanana β€” Gradio app for HuggingFace Spaces. + +Turns methodology text into publication-ready architecture diagrams +using a 5-agent pipeline (Retriever β†’ Planner β†’ Stylist β†’ Visualizer β†’ Critic). +""" + +import os +import json +import tempfile +import mimetypes +from pathlib import Path +from typing import List, Dict, Any, Optional + +import gradio as gr +from google import genai +from google.genai import types + +from agents import RetrieverAgent, PlannerAgent, StylistAgent, VisualizerAgent, CriticAgent +from aesthetic_guidelines import AESTHETIC_GUIDELINE +import config + +# ── Load reference set at startup ─────────────────────────────────────────── +REF_SET_PATH = Path("data/spotlight_reference_set.json") +REFERENCE_SET: List[Dict[str, Any]] = [] +if REF_SET_PATH.exists(): + with open(REF_SET_PATH) as f: + REFERENCE_SET = json.load(f) + print(f"Loaded {len(REFERENCE_SET)} reference examples") + +# ── Example gallery images ────────────────────────────────────────────────── +EXAMPLE_IMAGES = { + "Transformer": "examples/readme/transformer_iter3_0.jpg", + "ResNet": "examples/readme/resnet_iter3_0.jpg", + "DDPM": "examples/readme/ddpm_iter3_0.jpg", +} + +# ── Preset examples ───────────────────────────────────────────────────────── +PRESET_EXAMPLES = [ + [ + # Transformer + """The Transformer model follows an encoder-decoder structure using stacked self-attention and fully connected layers. + +Encoder: Stack of N=6 identical layers. Each layer has two sub-layers: (1) multi-head self-attention, and (2) position-wise feed-forward network. Residual connections around each sub-layer, followed by layer normalization. + +Decoder: Stack of N=6 identical layers. In addition to the two encoder sub-layers, the decoder inserts a third sub-layer for multi-head cross-attention over the encoder output. Masked self-attention prevents attending to subsequent positions. + +Multi-Head Attention: Linearly project queries, keys, values h times, perform scaled dot-product attention in parallel, concatenate and project again. + +Positional Encoding: Sinusoidal positional encodings added to input embeddings.""", + "The Transformer β€” model architecture (Vaswani et al., 2017)", + 2, + ], + [ + # ResNet + """We present a residual learning framework. Instead of learning H(x) directly, layers fit a residual mapping F(x) = H(x) - x. The building block is y = F(x, {W_i}) + x via identity shortcut connections. + +Architecture: Input 224Γ—224 β†’ 7Γ—7 conv, 64, stride 2 β†’ BN β†’ ReLU β†’ 3Γ—3 max pool β†’ Stage 1: 3 blocks, 64 filters β†’ Stage 2: 4 blocks, 128 filters β†’ Stage 3: 6 blocks, 256 filters β†’ Stage 4: 3 blocks, 512 filters β†’ Global avg pool β†’ 1000-d FC β†’ softmax. + +For deeper networks (50/101/152), bottleneck blocks: 1Γ—1 conv (reduce) β†’ 3Γ—3 conv β†’ 1Γ—1 conv (restore), with shortcut bypassing all three layers.""", + "Architecture of ResNet with residual learning building blocks (He et al., 2016)", + 2, + ], + [ + # DDPM + """Denoising diffusion probabilistic models (DDPMs): Forward process gradually adds Gaussian noise over T timesteps: q(x_t|x_{t-1}) = N(x_t; √(1-Ξ²_t)x_{t-1}, Ξ²_tI). After T steps, x_T β‰ˆ N(0,I). + +Reverse process learns to denoise: p_ΞΈ(x_{t-1}|x_t) = N(x_{t-1}; ΞΌ_ΞΈ(x_t,t), Ξ£_ΞΈ(x_t,t)). Starting from x_T ~ N(0,I), iteratively produces clean x_0. + +Denoising network Ξ΅_ΞΈ(x_t,t) is a U-Net: downsampling with ResNet blocks + self-attention at 16Γ—16, bottleneck with self-attention, upsampling with skip connections. Timestep conditioning via sinusoidal embeddings. Training minimizes L = E[||Ξ΅ - Ξ΅_ΞΈ(x_t,t)||Β²].""", + "Overview of the denoising diffusion probabilistic model (Ho et al., 2020)", + 2, + ], +] + + +# ── Core generation logic (streaming-friendly) ───────────────────────────── +def generate_diagram( + methodology_text: str, + caption: str, + num_iterations: int, + api_key: str | None = None, + progress=gr.Progress(track_tqdm=True), +): + """Run the full PaperBanana pipeline and yield intermediate results.""" + + # Resolve API key: user input > env var + gemini_key = (api_key or "").strip() or config.GEMINI_API_KEY + if not gemini_key: + raise gr.Error( + "No Gemini API key found. Paste one in the field above, " + "or set GEMINI_API_KEY as a Space secret." + ) + + # Patch config so all agents pick it up + config.GEMINI_API_KEY = gemini_key + + num_iterations = int(num_iterations) + logs: list[str] = [] + + def log(msg: str): + logs.append(msg) + return "\n".join(logs) + + # ── 1. Retriever ──────────────────────────────────────────────────────── + yield None, log("πŸ” [1/5] Retriever: finding relevant references…") + retriever = RetrieverAgent(REFERENCE_SET) + reference_examples = [] + if REFERENCE_SET: + reference_examples = retriever.retrieve( + methodology_text, caption, n=config.NUM_REFERENCE_EXAMPLES + ) + yield None, log(f" βœ“ Retrieved {len(reference_examples)} references") + else: + yield None, log(" ⏭ Skipped (no reference set loaded)") + + # ── 2. Planner ────────────────────────────────────────────────────────── + yield None, log("πŸ“ [2/5] Planner: creating visual description…") + planner = PlannerAgent() + current_description = planner.plan(methodology_text, caption, reference_examples) + yield None, log(f" βœ“ Description ready ({len(current_description)} chars)") + + # ── 3. Stylist ────────────────────────────────────────────────────────── + yield None, log("🎨 [3/5] Stylist: applying aesthetic guidelines…") + stylist = StylistAgent() + current_description = stylist.refine(current_description) + yield None, log(f" βœ“ Styled ({len(current_description)} chars)") + + # ── 4/5. Visualize β†’ Critique loop ────────────────────────────────────── + latest_image_path = None + critic = CriticAgent() + + for i in range(1, num_iterations + 1): + yield latest_image_path, log( + f"πŸ–ΌοΈ [4/5] Visualizer: generating image (iteration {i}/{num_iterations})…" + ) + + with tempfile.TemporaryDirectory() as tmpdir: + out_base = os.path.join(tmpdir, f"iter{i}") + visualizer = VisualizerAgent(mode="diagram") + img_path = visualizer.visualize(current_description, out_base) + + if img_path and os.path.exists(img_path): + # Copy to a persistent temp file so Gradio can serve it + import shutil + + ext = Path(img_path).suffix or ".jpg" + persist = tempfile.NamedTemporaryFile( + suffix=ext, delete=False, dir=tempfile.gettempdir() + ) + shutil.copy2(img_path, persist.name) + latest_image_path = persist.name + + yield latest_image_path, log(f" βœ“ Image generated (iteration {i})") + + # Skip critique on last iteration + if i >= num_iterations: + break + + yield latest_image_path, log( + f"πŸ”¬ [5/5] Critic: evaluating (iteration {i})…" + ) + critique = critic.critique( + methodology_text, caption, current_description, latest_image_path, i + ) + n_issues = len(critique["issues"]) + yield latest_image_path, log(f" βœ“ {n_issues} issues found") + + if not critique["should_continue"]: + yield latest_image_path, log(" βœ“ Quality threshold reached β€” done!") + break + + # Refine + yield latest_image_path, log("πŸ“ [2/5] Planner: refining description…") + refinement_prompt = critic.generate_refinement_prompt( + current_description, critique + ) + client = genai.Client(api_key=gemini_key) + contents = [ + types.Content( + role="user", + parts=[types.Part.from_text(text=refinement_prompt)], + ) + ] + refined = "" + for chunk in client.models.generate_content_stream( + model=config.VLM_MODEL, + contents=contents, + config=types.GenerateContentConfig( + thinking_config=types.ThinkingConfig(thinking_level="HIGH") + ), + ): + refined += chunk.text + current_description = refined.strip() + yield latest_image_path, log( + f" βœ“ Refined ({len(current_description)} chars)" + ) + + # Re-style + yield latest_image_path, log("🎨 [3/5] Stylist: re-applying style…") + current_description = stylist.refine(current_description) + yield latest_image_path, log(f" βœ“ Styled ({len(current_description)} chars)") + + yield latest_image_path, log("\nβœ… Generation complete!") + + +# ── Gradio UI ─────────────────────────────────────────────────────────────── +DESCRIPTION_MD = """\ +# 🍌 PaperBanana + +**Turn methodology text into publication-ready architecture diagrams.** + +Paste your paper's methodology section + a caption, and PaperBanana's 5-agent pipeline +(Retriever β†’ Planner β†’ Stylist β†’ Visualizer β†’ Critic) will generate a diagram for you. + +> Based on [*PaperBanana: Automating Academic Illustration for AI Scientists*](https://arxiv.org/abs/2505.23894) (Zhu et al., NeurIPS 2025). +""" + +with gr.Blocks( + title="PaperBanana", + theme=gr.themes.Soft(primary_hue="amber", secondary_hue="blue"), + css="footer { display: none !important; }", +) as demo: + gr.Markdown(DESCRIPTION_MD) + + # ── Example gallery ───────────────────────────────────────────────────── + with gr.Accordion("πŸ“Έ Example outputs (click to expand)", open=False): + existing = {k: v for k, v in EXAMPLE_IMAGES.items() if Path(v).exists()} + if existing: + with gr.Row(): + for name, path in existing.items(): + with gr.Column(min_width=200): + gr.Image(value=path, label=name) + + # ── Inputs ────────────────────────────────────────────────────────────── + with gr.Row(): + with gr.Column(scale=1): + methodology_input = gr.Textbox( + label="Methodology text", + placeholder="Paste your methodology / model description here…", + lines=12, + ) + caption_input = gr.Textbox( + label="Diagram caption", + placeholder='e.g. "Architecture of our proposed method"', + lines=2, + ) + iterations_slider = gr.Slider( + minimum=1, + maximum=3, + value=2, + step=1, + label="Refinement iterations", + info="More iterations = better quality, slower", + ) + api_key_input = gr.Textbox( + label="Gemini API key (optional if set as Space secret)", + type="password", + placeholder="AIza…", + ) + generate_btn = gr.Button("🍌 Generate diagram", variant="primary", size="lg") + + # ── Outputs ───────────────────────────────────────────────────────── + with gr.Column(scale=1): + output_image = gr.Image(label="Generated diagram", type="filepath") + output_log = gr.Textbox(label="Pipeline log", lines=18, interactive=False) + + # ── Examples table ────────────────────────────────────────────────────── + gr.Examples( + examples=PRESET_EXAMPLES, + inputs=[methodology_input, caption_input, iterations_slider], + label="Try a classic paper", + ) + + # ── Wiring ────────────────────────────────────────────────────────────── + generate_btn.click( + fn=generate_diagram, + inputs=[methodology_input, caption_input, iterations_slider, api_key_input], + outputs=[output_image, output_log], + ) + +if __name__ == "__main__": + demo.queue().launch(server_name="0.0.0.0", server_port=7860) diff --git a/config.py b/config.py new file mode 100644 index 0000000000000000000000000000000000000000..69406444fd79daa316750a8c0704ac846e346fd0 --- /dev/null +++ b/config.py @@ -0,0 +1,22 @@ +""" +Configuration for PaperBanana framework. +""" +import os +from dotenv import load_dotenv + +load_dotenv() + +# Gemini API Configuration +GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY") + +# Model Configuration +VLM_MODEL = "gemini-3-pro-preview" # For Retriever, Planner, Stylist, Critic +IMAGE_MODEL = "gemini-3-pro-image-preview" # For Visualizer (referred to as Nano-Banana-Pro in paper) + +# Generation Configuration +MAX_REFINEMENT_ITERATIONS = 3 # As per ablation study +IMAGE_SIZE = "1K" # Image resolution +THINKING_LEVEL = "HIGH" # For complex reasoning tasks + +# Number of reference examples to retrieve +NUM_REFERENCE_EXAMPLES = 10 diff --git a/data/spotlight_reference_images/ref_0001_00232_GraphMaster_Automated_Graph_Synthesis_via_LLM_Agents_in_Data-Limited_Environments__fdf13132133da88f7ce9ae4d0a22c29da1f05f75072f95010a29b1392696ea70.jpg b/data/spotlight_reference_images/ref_0001_00232_GraphMaster_Automated_Graph_Synthesis_via_LLM_Agents_in_Data-Limited_Environments__fdf13132133da88f7ce9ae4d0a22c29da1f05f75072f95010a29b1392696ea70.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b3a3b44209a906405a3f08bdae30972aa37a9a3 Binary files /dev/null and b/data/spotlight_reference_images/ref_0001_00232_GraphMaster_Automated_Graph_Synthesis_via_LLM_Agents_in_Data-Limited_Environments__fdf13132133da88f7ce9ae4d0a22c29da1f05f75072f95010a29b1392696ea70.jpg differ diff --git a/data/spotlight_reference_images/ref_0002_00279_VoxDet_Rethinking_3D_Semantic_Scene_Completion_as_Dense_Object_Detection__7b55d87bf0fcf6d787a440d59bf4617e6d73f10f5b1bcc1b45736ad0a7a57911.jpg b/data/spotlight_reference_images/ref_0002_00279_VoxDet_Rethinking_3D_Semantic_Scene_Completion_as_Dense_Object_Detection__7b55d87bf0fcf6d787a440d59bf4617e6d73f10f5b1bcc1b45736ad0a7a57911.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c668ca69bdd5780c841c74035b2110a367e15faf Binary files /dev/null and b/data/spotlight_reference_images/ref_0002_00279_VoxDet_Rethinking_3D_Semantic_Scene_Completion_as_Dense_Object_Detection__7b55d87bf0fcf6d787a440d59bf4617e6d73f10f5b1bcc1b45736ad0a7a57911.jpg differ diff --git a/data/spotlight_reference_images/ref_0003_00491_SQS_Enhancing_Sparse_Perception_Models_via_Query-based_Splatting_in_Autonomous_Driving__f7c6f154dc3e45e2f58f5a9111ebf57ead0d19f9e77340cd3838d881af17a916.jpg b/data/spotlight_reference_images/ref_0003_00491_SQS_Enhancing_Sparse_Perception_Models_via_Query-based_Splatting_in_Autonomous_Driving__f7c6f154dc3e45e2f58f5a9111ebf57ead0d19f9e77340cd3838d881af17a916.jpg new file mode 100644 index 0000000000000000000000000000000000000000..248ad0545f13aa26fa66a80be8a92d3b30513d0a Binary files /dev/null and b/data/spotlight_reference_images/ref_0003_00491_SQS_Enhancing_Sparse_Perception_Models_via_Query-based_Splatting_in_Autonomous_Driving__f7c6f154dc3e45e2f58f5a9111ebf57ead0d19f9e77340cd3838d881af17a916.jpg differ diff --git a/data/spotlight_reference_images/ref_0004_00691_ProtInvTree_Deliberate_Protein_Inverse_Folding_with_Reward-guided_Tree_Search__713bbbec11cbef0f1d2c8901e17165fa7db3d1fcf6cfa0d4a8b803d2dccb2ca0.jpg b/data/spotlight_reference_images/ref_0004_00691_ProtInvTree_Deliberate_Protein_Inverse_Folding_with_Reward-guided_Tree_Search__713bbbec11cbef0f1d2c8901e17165fa7db3d1fcf6cfa0d4a8b803d2dccb2ca0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..074f10354b3cf7f6c3ba4a6403f15be45560aeac Binary files /dev/null and b/data/spotlight_reference_images/ref_0004_00691_ProtInvTree_Deliberate_Protein_Inverse_Folding_with_Reward-guided_Tree_Search__713bbbec11cbef0f1d2c8901e17165fa7db3d1fcf6cfa0d4a8b803d2dccb2ca0.jpg differ diff --git a/data/spotlight_reference_images/ref_0005_00738_Mulberry_Empowering_MLLM_with_o1-like_Reasoning_and_Reflection_via_Collective_Monte_Carlo_Tree_Search__7c987fc8cf213eb47a038117cc38e5a170938289a390de4b8d7b6cd88512d505.jpg b/data/spotlight_reference_images/ref_0005_00738_Mulberry_Empowering_MLLM_with_o1-like_Reasoning_and_Reflection_via_Collective_Monte_Carlo_Tree_Search__7c987fc8cf213eb47a038117cc38e5a170938289a390de4b8d7b6cd88512d505.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0612e97f0f1d381e48c4e038569640a277c2d192 Binary files /dev/null and b/data/spotlight_reference_images/ref_0005_00738_Mulberry_Empowering_MLLM_with_o1-like_Reasoning_and_Reflection_via_Collective_Monte_Carlo_Tree_Search__7c987fc8cf213eb47a038117cc38e5a170938289a390de4b8d7b6cd88512d505.jpg differ diff --git a/data/spotlight_reference_images/ref_0006_00981_MesaTask_Towards_Task-Driven_Tabletop_Scene_Generation_via_3D_Spatial_Reasoning__ddce4bdb68a1689579a491b5a31349db83e5046fbb5424a45dc0883d4115e7d5.jpg b/data/spotlight_reference_images/ref_0006_00981_MesaTask_Towards_Task-Driven_Tabletop_Scene_Generation_via_3D_Spatial_Reasoning__ddce4bdb68a1689579a491b5a31349db83e5046fbb5424a45dc0883d4115e7d5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b12640fd928efeea6dc157bf5a8158d146c7a904 --- /dev/null +++ b/data/spotlight_reference_images/ref_0006_00981_MesaTask_Towards_Task-Driven_Tabletop_Scene_Generation_via_3D_Spatial_Reasoning__ddce4bdb68a1689579a491b5a31349db83e5046fbb5424a45dc0883d4115e7d5.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d04a1104d131abcf53056b5e5617593091f53bbf131d55ab2ce9b5f788b877d3 +size 130539 diff --git a/data/spotlight_reference_images/ref_0007_01003_OmniSync_Towards_Universal_Lip_Synchronization_via_Diffusion_Transformers__28d606ccd79ed54496343219767701efb0f445058d39887c1cf629a800942f77.jpg b/data/spotlight_reference_images/ref_0007_01003_OmniSync_Towards_Universal_Lip_Synchronization_via_Diffusion_Transformers__28d606ccd79ed54496343219767701efb0f445058d39887c1cf629a800942f77.jpg new file mode 100644 index 0000000000000000000000000000000000000000..40b0738a4503f6512d1178fc8e70fa955d39784f --- /dev/null +++ b/data/spotlight_reference_images/ref_0007_01003_OmniSync_Towards_Universal_Lip_Synchronization_via_Diffusion_Transformers__28d606ccd79ed54496343219767701efb0f445058d39887c1cf629a800942f77.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b34adeb1b8b47ab83bc6644a64894d538cd7418ba6657a72ccdcdfebd2d6ad56 +size 118968 diff --git a/data/spotlight_reference_images/ref_0008_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__ea910fb78f4d4027ff7fe9a63cbbc68a7038ee2e9f4250c2f773c631f265b079.jpg b/data/spotlight_reference_images/ref_0008_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__ea910fb78f4d4027ff7fe9a63cbbc68a7038ee2e9f4250c2f773c631f265b079.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17e654bbf9cee6d1b24dd2442a58a191c2acecdd Binary files /dev/null and b/data/spotlight_reference_images/ref_0008_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__ea910fb78f4d4027ff7fe9a63cbbc68a7038ee2e9f4250c2f773c631f265b079.jpg differ diff --git a/data/spotlight_reference_images/ref_0009_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__4cc6ca3e3fa15065b6a1781e9a7f814d67a46649325289b63c9bea4072020f4c.jpg b/data/spotlight_reference_images/ref_0009_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__4cc6ca3e3fa15065b6a1781e9a7f814d67a46649325289b63c9bea4072020f4c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5333ae2a867c438e51dbe4db47cd49b293f25470 Binary files /dev/null and b/data/spotlight_reference_images/ref_0009_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__4cc6ca3e3fa15065b6a1781e9a7f814d67a46649325289b63c9bea4072020f4c.jpg differ diff --git a/data/spotlight_reference_images/ref_0010_01112_DiCo_Revitalizing_ConvNets_for_Scalable_and_Efficient_Diffusion_Modeling__589d9f3ec341480c16ec00bf41076999cd0ce6c1526b97e71eb9c8ffe33b1a1b.jpg b/data/spotlight_reference_images/ref_0010_01112_DiCo_Revitalizing_ConvNets_for_Scalable_and_Efficient_Diffusion_Modeling__589d9f3ec341480c16ec00bf41076999cd0ce6c1526b97e71eb9c8ffe33b1a1b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8cf9ab099fc723234b7b13fdc40db8f8676b676a Binary files /dev/null and b/data/spotlight_reference_images/ref_0010_01112_DiCo_Revitalizing_ConvNets_for_Scalable_and_Efficient_Diffusion_Modeling__589d9f3ec341480c16ec00bf41076999cd0ce6c1526b97e71eb9c8ffe33b1a1b.jpg differ diff --git a/data/spotlight_reference_images/ref_0011_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__b501bcad7830654e421726b37ea0d89207d68c72f0f6aa9179fec65e0c71b205.jpg b/data/spotlight_reference_images/ref_0011_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__b501bcad7830654e421726b37ea0d89207d68c72f0f6aa9179fec65e0c71b205.jpg new file mode 100644 index 0000000000000000000000000000000000000000..850f70204b513a8e8a9dcc5892fbf3b858674836 --- /dev/null +++ b/data/spotlight_reference_images/ref_0011_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__b501bcad7830654e421726b37ea0d89207d68c72f0f6aa9179fec65e0c71b205.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2640c46c7a0d30a577808fbf2b7ed24c2821c1d1991fbec98f91c8c4e6c34556 +size 108773 diff --git a/data/spotlight_reference_images/ref_0012_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__fb4694d88a5097ee72a936634a832ced85d11e90079a4fabc3f1b8c28f24e5d6.jpg b/data/spotlight_reference_images/ref_0012_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__fb4694d88a5097ee72a936634a832ced85d11e90079a4fabc3f1b8c28f24e5d6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6aa8c63476c0b05bcc059d7f9634548d394333c9 Binary files /dev/null and b/data/spotlight_reference_images/ref_0012_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__fb4694d88a5097ee72a936634a832ced85d11e90079a4fabc3f1b8c28f24e5d6.jpg differ diff --git a/data/spotlight_reference_images/ref_0013_01620_FutureSightDrive_Thinking_Visually_with_Spatio-Temporal_CoT_for_Autonomous_Driving__8a4bffe9a69ef0d2bc0ced518bccdb3146d38727d7fc7402a418b6227a78bcfb.jpg b/data/spotlight_reference_images/ref_0013_01620_FutureSightDrive_Thinking_Visually_with_Spatio-Temporal_CoT_for_Autonomous_Driving__8a4bffe9a69ef0d2bc0ced518bccdb3146d38727d7fc7402a418b6227a78bcfb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d4c1b5f3726346d7a83ad6a6be29f3b739d2c6e Binary files /dev/null and b/data/spotlight_reference_images/ref_0013_01620_FutureSightDrive_Thinking_Visually_with_Spatio-Temporal_CoT_for_Autonomous_Driving__8a4bffe9a69ef0d2bc0ced518bccdb3146d38727d7fc7402a418b6227a78bcfb.jpg differ diff --git a/data/spotlight_reference_images/ref_0014_01659_G-Memory_Tracing_Hierarchical_Memory_for_Multi-Agent_Systems__48772f699bccd9ecf7285d9f2c4af85d34d60b7ee6b2cbd681278611869db12b.jpg b/data/spotlight_reference_images/ref_0014_01659_G-Memory_Tracing_Hierarchical_Memory_for_Multi-Agent_Systems__48772f699bccd9ecf7285d9f2c4af85d34d60b7ee6b2cbd681278611869db12b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..adef25c9ee5e14d078b2f6277228a29d3c804588 --- /dev/null +++ b/data/spotlight_reference_images/ref_0014_01659_G-Memory_Tracing_Hierarchical_Memory_for_Multi-Agent_Systems__48772f699bccd9ecf7285d9f2c4af85d34d60b7ee6b2cbd681278611869db12b.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a81e26be68336192dda8116ef0df8001d34ee61398a633266559e1f780cc2e0b +size 170264 diff --git a/data/spotlight_reference_images/ref_0015_01839_Mesh-RFT_Enhancing_Mesh_Generation_via_Fine-grained_Reinforcement_Fine-Tuning__4d93550a61cdae636652e7cd1ca974c21c7fca1e8eb6eaa6fa2e03100f1d0f68.jpg b/data/spotlight_reference_images/ref_0015_01839_Mesh-RFT_Enhancing_Mesh_Generation_via_Fine-grained_Reinforcement_Fine-Tuning__4d93550a61cdae636652e7cd1ca974c21c7fca1e8eb6eaa6fa2e03100f1d0f68.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e2f9a9274c4e7396729e2ac1663b4ca12aec3e05 Binary files /dev/null and b/data/spotlight_reference_images/ref_0015_01839_Mesh-RFT_Enhancing_Mesh_Generation_via_Fine-grained_Reinforcement_Fine-Tuning__4d93550a61cdae636652e7cd1ca974c21c7fca1e8eb6eaa6fa2e03100f1d0f68.jpg differ diff --git a/data/spotlight_reference_images/ref_0016_01864_Jacobian-Based_Interpretation_of_Nonlinear_Neural_Encoding_Model__c9ac984c977d21aff284dcfbacf7bdfea345cc73096a3f28d624b026654e1740.jpg b/data/spotlight_reference_images/ref_0016_01864_Jacobian-Based_Interpretation_of_Nonlinear_Neural_Encoding_Model__c9ac984c977d21aff284dcfbacf7bdfea345cc73096a3f28d624b026654e1740.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0a80a9f3ceb83469138e233a4865ac30254f6f85 Binary files /dev/null and b/data/spotlight_reference_images/ref_0016_01864_Jacobian-Based_Interpretation_of_Nonlinear_Neural_Encoding_Model__c9ac984c977d21aff284dcfbacf7bdfea345cc73096a3f28d624b026654e1740.jpg differ diff --git a/data/spotlight_reference_images/ref_0017_02109_OnlineSplatter_Pose-Free_Online_3D_Reconstruction_for_Free-Moving_Objects__abe4e12f0fc9a7487c6c5774f5ead6b391ede9f832960b5ce462ceb786534a0d.jpg b/data/spotlight_reference_images/ref_0017_02109_OnlineSplatter_Pose-Free_Online_3D_Reconstruction_for_Free-Moving_Objects__abe4e12f0fc9a7487c6c5774f5ead6b391ede9f832960b5ce462ceb786534a0d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8d114fafbd6059d7455ec5a86267cd111b3a837d Binary files /dev/null and b/data/spotlight_reference_images/ref_0017_02109_OnlineSplatter_Pose-Free_Online_3D_Reconstruction_for_Free-Moving_Objects__abe4e12f0fc9a7487c6c5774f5ead6b391ede9f832960b5ce462ceb786534a0d.jpg differ diff --git a/data/spotlight_reference_images/ref_0018_02239_RobustMerge_Parameter-Efficient_Model_Merging_for_MLLMs_with_Direction_Robustness__45b74fc957d305067e6f46f00bc32c9ee0889b7dc7e18b4c46913d263c1d8c16.jpg b/data/spotlight_reference_images/ref_0018_02239_RobustMerge_Parameter-Efficient_Model_Merging_for_MLLMs_with_Direction_Robustness__45b74fc957d305067e6f46f00bc32c9ee0889b7dc7e18b4c46913d263c1d8c16.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eb50e61ea199788029bdcfbb5fec0c2597f8129b Binary files /dev/null and b/data/spotlight_reference_images/ref_0018_02239_RobustMerge_Parameter-Efficient_Model_Merging_for_MLLMs_with_Direction_Robustness__45b74fc957d305067e6f46f00bc32c9ee0889b7dc7e18b4c46913d263c1d8c16.jpg differ diff --git a/data/spotlight_reference_images/ref_0019_02373_MDReID_Modality-Decoupled_Learning_for_Any-to-Any_Multi-Modal_Object_Re-Identification__517a2ed3f7dd16e048d526da7807ac8b1b73cdb062b79021b7047dd0b467ba9a.jpg b/data/spotlight_reference_images/ref_0019_02373_MDReID_Modality-Decoupled_Learning_for_Any-to-Any_Multi-Modal_Object_Re-Identification__517a2ed3f7dd16e048d526da7807ac8b1b73cdb062b79021b7047dd0b467ba9a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..44630561f6524524934f56bc9896720831182405 --- /dev/null +++ b/data/spotlight_reference_images/ref_0019_02373_MDReID_Modality-Decoupled_Learning_for_Any-to-Any_Multi-Modal_Object_Re-Identification__517a2ed3f7dd16e048d526da7807ac8b1b73cdb062b79021b7047dd0b467ba9a.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3350f54f56d42f88c3d4e8da2fe5b3ce9b1b178d2c6a8a1d3097a1a34f630569 +size 122361 diff --git a/data/spotlight_reference_images/ref_0020_03077_Toward_Relative_Positional_Encoding_in_Spiking_Transformers__bdb178031ec8d263c3a5388d900e974b8ce39ae5759a6611f688a57e22173fa5.jpg b/data/spotlight_reference_images/ref_0020_03077_Toward_Relative_Positional_Encoding_in_Spiking_Transformers__bdb178031ec8d263c3a5388d900e974b8ce39ae5759a6611f688a57e22173fa5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e873facd80ef057f07b18a8a20e6d59c73cac7d9 --- /dev/null +++ b/data/spotlight_reference_images/ref_0020_03077_Toward_Relative_Positional_Encoding_in_Spiking_Transformers__bdb178031ec8d263c3a5388d900e974b8ce39ae5759a6611f688a57e22173fa5.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e924e108575f4d47a892f436788c8fa5669282ed5bad2882568222daf634c1a5 +size 117621 diff --git a/data/spotlight_reference_images/ref_0021_03670_Neural_Atlas_Graphs_for_Dynamic_Scene_Decomposition_and_Editing__16f8fc865baed696e798502de56f3b473dbf2b0b6aa3c1286f384de53c524b97.jpg b/data/spotlight_reference_images/ref_0021_03670_Neural_Atlas_Graphs_for_Dynamic_Scene_Decomposition_and_Editing__16f8fc865baed696e798502de56f3b473dbf2b0b6aa3c1286f384de53c524b97.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fea7d06553ac04108a05e2e37e7a93d9b6ee7148 Binary files /dev/null and b/data/spotlight_reference_images/ref_0021_03670_Neural_Atlas_Graphs_for_Dynamic_Scene_Decomposition_and_Editing__16f8fc865baed696e798502de56f3b473dbf2b0b6aa3c1286f384de53c524b97.jpg differ diff --git a/data/spotlight_reference_images/ref_0022_03671_STITCH-OPE_Trajectory_Stitching_with_Guided_Diffusion_for_Off-Policy_Evaluation__6e9c875dbc74a8b39bc947de3b928f8a29f7c6db9b03d726a62a961ba0c2fdd3.jpg b/data/spotlight_reference_images/ref_0022_03671_STITCH-OPE_Trajectory_Stitching_with_Guided_Diffusion_for_Off-Policy_Evaluation__6e9c875dbc74a8b39bc947de3b928f8a29f7c6db9b03d726a62a961ba0c2fdd3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be726455e0ba74cb5e16e355bb408ea66e6fdcd0 Binary files /dev/null and b/data/spotlight_reference_images/ref_0022_03671_STITCH-OPE_Trajectory_Stitching_with_Guided_Diffusion_for_Off-Policy_Evaluation__6e9c875dbc74a8b39bc947de3b928f8a29f7c6db9b03d726a62a961ba0c2fdd3.jpg differ diff --git a/data/spotlight_reference_images/ref_0023_04013_scMRDR_A_scalable_and_flexible_framework_for_unpaired_single-cell_multi-omics_data_integration__85cde1b5a410b0d3275a5c0fa81dfe69e2c83c485c9917c296502a6485e2f68b.jpg b/data/spotlight_reference_images/ref_0023_04013_scMRDR_A_scalable_and_flexible_framework_for_unpaired_single-cell_multi-omics_data_integration__85cde1b5a410b0d3275a5c0fa81dfe69e2c83c485c9917c296502a6485e2f68b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..183502673f1c5c0f70bb8ca068d682266d2d4b69 Binary files /dev/null and b/data/spotlight_reference_images/ref_0023_04013_scMRDR_A_scalable_and_flexible_framework_for_unpaired_single-cell_multi-omics_data_integration__85cde1b5a410b0d3275a5c0fa81dfe69e2c83c485c9917c296502a6485e2f68b.jpg differ diff --git a/data/spotlight_reference_images/ref_0024_04165_Transformer_Copilot_Learning_from_The_Mistake_Log_in_LLM_Fine-tuning__8d1e804f51825d9760a37b8d1ca027a61deecc5e33fc172f0c1789814527c37e.jpg b/data/spotlight_reference_images/ref_0024_04165_Transformer_Copilot_Learning_from_The_Mistake_Log_in_LLM_Fine-tuning__8d1e804f51825d9760a37b8d1ca027a61deecc5e33fc172f0c1789814527c37e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e537b52d670ef657b9df939d029e3b4b457f9d3 Binary files /dev/null and b/data/spotlight_reference_images/ref_0024_04165_Transformer_Copilot_Learning_from_The_Mistake_Log_in_LLM_Fine-tuning__8d1e804f51825d9760a37b8d1ca027a61deecc5e33fc172f0c1789814527c37e.jpg differ diff --git a/data/spotlight_reference_images/ref_0025_04571_GeRaF_Neural_Geometry_Reconstruction_from_Radio_Frequency_Signals__e096c21c76e1eb88c8d865f73e832e8e9246cddec17f62b5d85bc051caa55165.jpg b/data/spotlight_reference_images/ref_0025_04571_GeRaF_Neural_Geometry_Reconstruction_from_Radio_Frequency_Signals__e096c21c76e1eb88c8d865f73e832e8e9246cddec17f62b5d85bc051caa55165.jpg new file mode 100644 index 0000000000000000000000000000000000000000..12eb1b1672a8526ac06dcb58e36140d211262c25 Binary files /dev/null and b/data/spotlight_reference_images/ref_0025_04571_GeRaF_Neural_Geometry_Reconstruction_from_Radio_Frequency_Signals__e096c21c76e1eb88c8d865f73e832e8e9246cddec17f62b5d85bc051caa55165.jpg differ diff --git a/data/spotlight_reference_images/ref_0026_04647_HopaDIFF_Holistic-Partial_Aware_Fourier_Conditioned_Diffusion_for_Referring_Human_Action_Segmentation_in_Multi-Person_Sc__0e15e7e99b52ccbc157e3ee04a6de2238b23ccd60543102fc2a70eddb12e5e41.jpg b/data/spotlight_reference_images/ref_0026_04647_HopaDIFF_Holistic-Partial_Aware_Fourier_Conditioned_Diffusion_for_Referring_Human_Action_Segmentation_in_Multi-Person_Sc__0e15e7e99b52ccbc157e3ee04a6de2238b23ccd60543102fc2a70eddb12e5e41.jpg new file mode 100644 index 0000000000000000000000000000000000000000..835be78ad6cdf383f8d8311ec6d85d722deed305 Binary files /dev/null and b/data/spotlight_reference_images/ref_0026_04647_HopaDIFF_Holistic-Partial_Aware_Fourier_Conditioned_Diffusion_for_Referring_Human_Action_Segmentation_in_Multi-Person_Sc__0e15e7e99b52ccbc157e3ee04a6de2238b23ccd60543102fc2a70eddb12e5e41.jpg differ diff --git a/data/spotlight_reference_images/ref_0027_04717_CSBrain_A_Cross-scale_Spatiotemporal_Brain_Foundation_Model_for_EEG_Decoding__327e1ef5f11138cef78e3dd270f09eea700aedb3c5a64cf848b125d13e4e5f08.jpg b/data/spotlight_reference_images/ref_0027_04717_CSBrain_A_Cross-scale_Spatiotemporal_Brain_Foundation_Model_for_EEG_Decoding__327e1ef5f11138cef78e3dd270f09eea700aedb3c5a64cf848b125d13e4e5f08.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b983571e9bf90b650b2b5498c6a3c7e039fc1bc Binary files /dev/null and b/data/spotlight_reference_images/ref_0027_04717_CSBrain_A_Cross-scale_Spatiotemporal_Brain_Foundation_Model_for_EEG_Decoding__327e1ef5f11138cef78e3dd270f09eea700aedb3c5a64cf848b125d13e4e5f08.jpg differ diff --git a/data/spotlight_reference_images/ref_0028_05129_Learning_to_Factorize_Spatio-Temporal_Foundation_Models__ef11d1775e9863839bc4dfaf8711bf474ef80365303220ba92781b579879e7a5.jpg b/data/spotlight_reference_images/ref_0028_05129_Learning_to_Factorize_Spatio-Temporal_Foundation_Models__ef11d1775e9863839bc4dfaf8711bf474ef80365303220ba92781b579879e7a5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9dc88c7d36fc2f10b80fac27b87503f61a2d2e35 Binary files /dev/null and b/data/spotlight_reference_images/ref_0028_05129_Learning_to_Factorize_Spatio-Temporal_Foundation_Models__ef11d1775e9863839bc4dfaf8711bf474ef80365303220ba92781b579879e7a5.jpg differ diff --git a/data/spotlight_reference_images/ref_0029_05428_EDELINE_Enhancing_Memory_in_Diffusion-based_World_Models_via_Linear-Time_Sequence_Modeling__57df86687acccd0bad49997d26a4a442d6d09e2381e5a570d1d1e7efd02cf303.jpg b/data/spotlight_reference_images/ref_0029_05428_EDELINE_Enhancing_Memory_in_Diffusion-based_World_Models_via_Linear-Time_Sequence_Modeling__57df86687acccd0bad49997d26a4a442d6d09e2381e5a570d1d1e7efd02cf303.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bedafce78c5074a138af22b1dcd570a2c3d281ed Binary files /dev/null and b/data/spotlight_reference_images/ref_0029_05428_EDELINE_Enhancing_Memory_in_Diffusion-based_World_Models_via_Linear-Time_Sequence_Modeling__57df86687acccd0bad49997d26a4a442d6d09e2381e5a570d1d1e7efd02cf303.jpg differ diff --git a/data/spotlight_reference_images/ref_0030_05467_Vision-centric_Token_Compression_in_Large_Language_Model__056bbf059f83c91ea896c610cef2927606ab780d910996e6cdb293dfaca40ddd.jpg b/data/spotlight_reference_images/ref_0030_05467_Vision-centric_Token_Compression_in_Large_Language_Model__056bbf059f83c91ea896c610cef2927606ab780d910996e6cdb293dfaca40ddd.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b0471f87a7be7adbd23f4f82ac9f46631218266d Binary files /dev/null and b/data/spotlight_reference_images/ref_0030_05467_Vision-centric_Token_Compression_in_Large_Language_Model__056bbf059f83c91ea896c610cef2927606ab780d910996e6cdb293dfaca40ddd.jpg differ diff --git a/data/spotlight_reference_images/ref_0031_05610_Repo2Run_Automated_Building_Executable_Environment_for_Code_Repository_at_Scale__ea96f359e23ff3f0427d48dd3247314967bb531150d725a7680376b940324680.jpg b/data/spotlight_reference_images/ref_0031_05610_Repo2Run_Automated_Building_Executable_Environment_for_Code_Repository_at_Scale__ea96f359e23ff3f0427d48dd3247314967bb531150d725a7680376b940324680.jpg new file mode 100644 index 0000000000000000000000000000000000000000..33cfa96544b9d28363ddd816e47d0042311bc63c Binary files /dev/null and b/data/spotlight_reference_images/ref_0031_05610_Repo2Run_Automated_Building_Executable_Environment_for_Code_Repository_at_Scale__ea96f359e23ff3f0427d48dd3247314967bb531150d725a7680376b940324680.jpg differ diff --git a/data/spotlight_reference_images/ref_0032_05774_Shallow_Diffuse_Robust_and_Invisible_Watermarking_through_Low-Dim_Subspaces_in_Diffusion_Models__703f7602f642aa354858ee8cf929888d672a45001a93ac0cb937cd0f4f1b62de.jpg b/data/spotlight_reference_images/ref_0032_05774_Shallow_Diffuse_Robust_and_Invisible_Watermarking_through_Low-Dim_Subspaces_in_Diffusion_Models__703f7602f642aa354858ee8cf929888d672a45001a93ac0cb937cd0f4f1b62de.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8ff219a4b3b288af0c100860ef402c96092349b0 Binary files /dev/null and b/data/spotlight_reference_images/ref_0032_05774_Shallow_Diffuse_Robust_and_Invisible_Watermarking_through_Low-Dim_Subspaces_in_Diffusion_Models__703f7602f642aa354858ee8cf929888d672a45001a93ac0cb937cd0f4f1b62de.jpg differ diff --git a/data/spotlight_reference_images/ref_0033_05814_Mozart_Modularized_and_Efficient_MoE_Training_on_35D_Wafer-Scale_Chiplet_Architectures__dc6b73dd98f93241717e3b658c319f70ab6ad6188c24a147cd052fb2153d656d.jpg b/data/spotlight_reference_images/ref_0033_05814_Mozart_Modularized_and_Efficient_MoE_Training_on_35D_Wafer-Scale_Chiplet_Architectures__dc6b73dd98f93241717e3b658c319f70ab6ad6188c24a147cd052fb2153d656d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..938a8fd8cc43229fdc1b8dbce962c5a5b3137f43 Binary files /dev/null and b/data/spotlight_reference_images/ref_0033_05814_Mozart_Modularized_and_Efficient_MoE_Training_on_35D_Wafer-Scale_Chiplet_Architectures__dc6b73dd98f93241717e3b658c319f70ab6ad6188c24a147cd052fb2153d656d.jpg differ diff --git a/data/spotlight_reference_images/ref_0034_06044_Theory-Driven_Label-Specific_Representation_for_Incomplete_Multi-View_Multi-Label_Learning__4d4bbb3c5cd4edb56f73502b7eac2b526f30bfc883b337d949cb38ee0747ee22.jpg b/data/spotlight_reference_images/ref_0034_06044_Theory-Driven_Label-Specific_Representation_for_Incomplete_Multi-View_Multi-Label_Learning__4d4bbb3c5cd4edb56f73502b7eac2b526f30bfc883b337d949cb38ee0747ee22.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1d3d895af0c58c114818de9d65c7ce6ed5736416 Binary files /dev/null and b/data/spotlight_reference_images/ref_0034_06044_Theory-Driven_Label-Specific_Representation_for_Incomplete_Multi-View_Multi-Label_Learning__4d4bbb3c5cd4edb56f73502b7eac2b526f30bfc883b337d949cb38ee0747ee22.jpg differ diff --git a/data/spotlight_reference_images/ref_0035_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__8c0d4df1862409d631870861dc2f047a0cd2572e87267d0d3ea58b6c245408fe.jpg b/data/spotlight_reference_images/ref_0035_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__8c0d4df1862409d631870861dc2f047a0cd2572e87267d0d3ea58b6c245408fe.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5a5f870b2850ba951994275ac2ee489fda1b2d9d Binary files /dev/null and b/data/spotlight_reference_images/ref_0035_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__8c0d4df1862409d631870861dc2f047a0cd2572e87267d0d3ea58b6c245408fe.jpg differ diff --git a/data/spotlight_reference_images/ref_0036_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__a50d002b445446ba0c687045ba485e4c96aaf49765198b3f53fb954327df6f4f.jpg b/data/spotlight_reference_images/ref_0036_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__a50d002b445446ba0c687045ba485e4c96aaf49765198b3f53fb954327df6f4f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..163a7d60ef37adcb9b2b2dc5abf1b9c133f59954 Binary files /dev/null and b/data/spotlight_reference_images/ref_0036_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__a50d002b445446ba0c687045ba485e4c96aaf49765198b3f53fb954327df6f4f.jpg differ diff --git a/data/spotlight_reference_images/ref_0037_06507_CausalPFN_Amortized_Causal_Effect_Estimation_via_In-Context_Learning__8c660a9d9ad153e854bc67151e7df9977e2244fa4ce9bd649c2b08b58db2e30c.jpg b/data/spotlight_reference_images/ref_0037_06507_CausalPFN_Amortized_Causal_Effect_Estimation_via_In-Context_Learning__8c660a9d9ad153e854bc67151e7df9977e2244fa4ce9bd649c2b08b58db2e30c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6ab5d76e663134dc82ba3009978fd1cb23e9c543 Binary files /dev/null and b/data/spotlight_reference_images/ref_0037_06507_CausalPFN_Amortized_Causal_Effect_Estimation_via_In-Context_Learning__8c660a9d9ad153e854bc67151e7df9977e2244fa4ce9bd649c2b08b58db2e30c.jpg differ diff --git a/data/spotlight_reference_images/ref_0038_06527_Robust_Graph_Condensation_via_Classification_Complexity_Mitigation__dedb33c198673910da24a5a2a5794a8228afce42d7b46ff594dab0cac9ee61e0.jpg b/data/spotlight_reference_images/ref_0038_06527_Robust_Graph_Condensation_via_Classification_Complexity_Mitigation__dedb33c198673910da24a5a2a5794a8228afce42d7b46ff594dab0cac9ee61e0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eaef21af776c3b3995b7a177fcc3b698678db5be --- /dev/null +++ b/data/spotlight_reference_images/ref_0038_06527_Robust_Graph_Condensation_via_Classification_Complexity_Mitigation__dedb33c198673910da24a5a2a5794a8228afce42d7b46ff594dab0cac9ee61e0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0130a54d1dacffb6ae73bee7e2cc8694b25045adc6bcf1e4f1f5af6e41480187 +size 104415 diff --git a/data/spotlight_reference_images/ref_0039_06555_Physics-Driven_Spatiotemporal_Modeling_for_AI-Generated_Video_Detection__7960731d2cf65306fb2ccf2b4dc3792ed55197a1c561f04d82e6b487b2023fdf.jpg b/data/spotlight_reference_images/ref_0039_06555_Physics-Driven_Spatiotemporal_Modeling_for_AI-Generated_Video_Detection__7960731d2cf65306fb2ccf2b4dc3792ed55197a1c561f04d82e6b487b2023fdf.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a91feab46696e1266d84beb6a6bcce33727dd5ce Binary files /dev/null and b/data/spotlight_reference_images/ref_0039_06555_Physics-Driven_Spatiotemporal_Modeling_for_AI-Generated_Video_Detection__7960731d2cf65306fb2ccf2b4dc3792ed55197a1c561f04d82e6b487b2023fdf.jpg differ diff --git a/data/spotlight_reference_images/ref_0040_06606_Disentangled_Concepts_Speak_Louder_Than_Words_Explainable_Video_Action_Recognition__fe96a76b160d3861e188cfe5511fee2d4f07eada1ebf92ade017048a3362d5b8.jpg b/data/spotlight_reference_images/ref_0040_06606_Disentangled_Concepts_Speak_Louder_Than_Words_Explainable_Video_Action_Recognition__fe96a76b160d3861e188cfe5511fee2d4f07eada1ebf92ade017048a3362d5b8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..978d448d9f84b5f9a23b3bbfcf9062f2d282d4f6 --- /dev/null +++ b/data/spotlight_reference_images/ref_0040_06606_Disentangled_Concepts_Speak_Louder_Than_Words_Explainable_Video_Action_Recognition__fe96a76b160d3861e188cfe5511fee2d4f07eada1ebf92ade017048a3362d5b8.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1093a31e2e308f2739472213df57d2eeb71f63660d377a7be38fc35d9df978f +size 112681 diff --git a/data/spotlight_reference_images/ref_0041_07858_HYPERION_Fine-Grained_Hypersphere_Alignment_for_Robust_Federated_Graph_Learning__be29a99497ec2dd4d3a8993ce3edc85c87505a1cabfadc2df234b7e326633ebc.jpg b/data/spotlight_reference_images/ref_0041_07858_HYPERION_Fine-Grained_Hypersphere_Alignment_for_Robust_Federated_Graph_Learning__be29a99497ec2dd4d3a8993ce3edc85c87505a1cabfadc2df234b7e326633ebc.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9ebed2ce28e0f6001c25c4a56ee1da589f3ee06e --- /dev/null +++ b/data/spotlight_reference_images/ref_0041_07858_HYPERION_Fine-Grained_Hypersphere_Alignment_for_Robust_Federated_Graph_Learning__be29a99497ec2dd4d3a8993ce3edc85c87505a1cabfadc2df234b7e326633ebc.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f69aca7e11124ac45089b58a5edfe2f24e500631f04e35e0302efbdaac3b69f1 +size 128337 diff --git a/data/spotlight_reference_images/ref_0042_07877_SIU3R_Simultaneous_Scene_Understanding_and_3D_Reconstruction_Beyond_Feature_Alignment__4e6a5833ae5b980087c2b2a4288f152fec9b55ec42be718174ed81724ea898ac.jpg b/data/spotlight_reference_images/ref_0042_07877_SIU3R_Simultaneous_Scene_Understanding_and_3D_Reconstruction_Beyond_Feature_Alignment__4e6a5833ae5b980087c2b2a4288f152fec9b55ec42be718174ed81724ea898ac.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab927e3f35f7f2ddc281c21712e9ec52ccd81ac6 Binary files /dev/null and b/data/spotlight_reference_images/ref_0042_07877_SIU3R_Simultaneous_Scene_Understanding_and_3D_Reconstruction_Beyond_Feature_Alignment__4e6a5833ae5b980087c2b2a4288f152fec9b55ec42be718174ed81724ea898ac.jpg differ diff --git a/data/spotlight_reference_images/ref_0043_08772_RepoMaster_Autonomous_Exploration_and_Understanding_of_GitHub_Repositories_for_Complex_Task_Solving__c5102f7309c920d53df2307418ef99304d083aa3f54140e3fa2e55c6b259378b.jpg b/data/spotlight_reference_images/ref_0043_08772_RepoMaster_Autonomous_Exploration_and_Understanding_of_GitHub_Repositories_for_Complex_Task_Solving__c5102f7309c920d53df2307418ef99304d083aa3f54140e3fa2e55c6b259378b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..87f21a1e3ae21e00fb55cb2c119d84cead5bb352 --- /dev/null +++ b/data/spotlight_reference_images/ref_0043_08772_RepoMaster_Autonomous_Exploration_and_Understanding_of_GitHub_Repositories_for_Complex_Task_Solving__c5102f7309c920d53df2307418ef99304d083aa3f54140e3fa2e55c6b259378b.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4e3319940bc4985f2811c915f970e5d2c1da7e1cf35f51ad1c23c3f589ba7d6 +size 147056 diff --git a/data/spotlight_reference_images/ref_0044_08831_MJ-Video_Benchmarking_and_Rewarding_Video_Generation_with_Fine-Grained_Video_Preference__75e635ce2d8e5e0690b91f12cda2422729f5d490691b83e8e3e97e80635a298f.jpg b/data/spotlight_reference_images/ref_0044_08831_MJ-Video_Benchmarking_and_Rewarding_Video_Generation_with_Fine-Grained_Video_Preference__75e635ce2d8e5e0690b91f12cda2422729f5d490691b83e8e3e97e80635a298f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6dd4c21b3712f18e16887d9830618f658f02320f Binary files /dev/null and b/data/spotlight_reference_images/ref_0044_08831_MJ-Video_Benchmarking_and_Rewarding_Video_Generation_with_Fine-Grained_Video_Preference__75e635ce2d8e5e0690b91f12cda2422729f5d490691b83e8e3e97e80635a298f.jpg differ diff --git a/data/spotlight_reference_images/ref_0045_08849_SparseMVC_Probing_Cross-view_Sparsity_Variations_for_Multi-view_Clustering__a2db56ea4b3f2d64de561e0fe461b0b49389f5dea822175ac4ad074f1e2e29c8.jpg b/data/spotlight_reference_images/ref_0045_08849_SparseMVC_Probing_Cross-view_Sparsity_Variations_for_Multi-view_Clustering__a2db56ea4b3f2d64de561e0fe461b0b49389f5dea822175ac4ad074f1e2e29c8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..165e98bc6e341593f2accd3a0d5e948b5ae03063 Binary files /dev/null and b/data/spotlight_reference_images/ref_0045_08849_SparseMVC_Probing_Cross-view_Sparsity_Variations_for_Multi-view_Clustering__a2db56ea4b3f2d64de561e0fe461b0b49389f5dea822175ac4ad074f1e2e29c8.jpg differ diff --git a/data/spotlight_reference_images/ref_0046_09315_Personalized_Decision_Modeling_Utility_Optimization_or_Textualized-Symbolic_Reasoning__56df140d7973f4f1a6286c7cebec84068dc6828711cea2e455416a0d9d381a99.jpg b/data/spotlight_reference_images/ref_0046_09315_Personalized_Decision_Modeling_Utility_Optimization_or_Textualized-Symbolic_Reasoning__56df140d7973f4f1a6286c7cebec84068dc6828711cea2e455416a0d9d381a99.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce44621c86cb695569e9ef3852009f017dd9f281 --- /dev/null +++ b/data/spotlight_reference_images/ref_0046_09315_Personalized_Decision_Modeling_Utility_Optimization_or_Textualized-Symbolic_Reasoning__56df140d7973f4f1a6286c7cebec84068dc6828711cea2e455416a0d9d381a99.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11641fa269679bdca10a048ad755e552e94c8864aa8d0db095f3a752c22d76c2 +size 114399 diff --git a/data/spotlight_reference_images/ref_0047_09480_EGGS_Exchangeable_2D3D_Gaussian_Splatting_for_Geometry-Appearance_Balanced_Novel_View_Synthesis__9689645411efcd4495c333462949c56751f3277cd5d1500389c0121fc710deb6.jpg b/data/spotlight_reference_images/ref_0047_09480_EGGS_Exchangeable_2D3D_Gaussian_Splatting_for_Geometry-Appearance_Balanced_Novel_View_Synthesis__9689645411efcd4495c333462949c56751f3277cd5d1500389c0121fc710deb6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e1074157e72e048b7f6b349e2550e8fbe28bbe1 Binary files /dev/null and b/data/spotlight_reference_images/ref_0047_09480_EGGS_Exchangeable_2D3D_Gaussian_Splatting_for_Geometry-Appearance_Balanced_Novel_View_Synthesis__9689645411efcd4495c333462949c56751f3277cd5d1500389c0121fc710deb6.jpg differ diff --git a/data/spotlight_reference_images/ref_0048_09629_4DGT_Learning_a_4D_Gaussian_Transformer_Using_Real-World_Monocular_Videos__64516a621163af326843f0152bd0cdb8f798d2df70242271249a95e572c7a300.jpg b/data/spotlight_reference_images/ref_0048_09629_4DGT_Learning_a_4D_Gaussian_Transformer_Using_Real-World_Monocular_Videos__64516a621163af326843f0152bd0cdb8f798d2df70242271249a95e572c7a300.jpg new file mode 100644 index 0000000000000000000000000000000000000000..795ba4164bd391c687ca8a03ce6a9656c74c49e3 --- /dev/null +++ b/data/spotlight_reference_images/ref_0048_09629_4DGT_Learning_a_4D_Gaussian_Transformer_Using_Real-World_Monocular_Videos__64516a621163af326843f0152bd0cdb8f798d2df70242271249a95e572c7a300.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45545b369c4274077c91949227e440dd35ced1471532803d85a4a2dfb8fd18b4 +size 121510 diff --git a/data/spotlight_reference_images/ref_0049_09928_BevSplat_Resolving_Height_Ambiguity_via_Feature-Based_Gaussian_Primitives_for_Weakly-Supervised_Cross-View_Localization__a8331d7a8730d2f09ad6fc49f9b8a2d75ad13192be31bd73dcb2c815b8158115.jpg b/data/spotlight_reference_images/ref_0049_09928_BevSplat_Resolving_Height_Ambiguity_via_Feature-Based_Gaussian_Primitives_for_Weakly-Supervised_Cross-View_Localization__a8331d7a8730d2f09ad6fc49f9b8a2d75ad13192be31bd73dcb2c815b8158115.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3da109f2ee2cd1831b50690fc83e11f1c5afb6dc Binary files /dev/null and b/data/spotlight_reference_images/ref_0049_09928_BevSplat_Resolving_Height_Ambiguity_via_Feature-Based_Gaussian_Primitives_for_Weakly-Supervised_Cross-View_Localization__a8331d7a8730d2f09ad6fc49f9b8a2d75ad13192be31bd73dcb2c815b8158115.jpg differ diff --git a/data/spotlight_reference_images/ref_0050_10276_MigGPT_Harnessing_Large_Language_Models_for_Automated_Migration_of_Out-of-Tree_Linux_Kernel_Patches_Across_Versions__bf73363f403e6fcd1c61336c24e5882a6550413e3f8448bad34b1b38b253e2d8.jpg b/data/spotlight_reference_images/ref_0050_10276_MigGPT_Harnessing_Large_Language_Models_for_Automated_Migration_of_Out-of-Tree_Linux_Kernel_Patches_Across_Versions__bf73363f403e6fcd1c61336c24e5882a6550413e3f8448bad34b1b38b253e2d8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f0f00e14d1826bfc4bc30b81cb3989c62840ef29 Binary files /dev/null and b/data/spotlight_reference_images/ref_0050_10276_MigGPT_Harnessing_Large_Language_Models_for_Automated_Migration_of_Out-of-Tree_Linux_Kernel_Patches_Across_Versions__bf73363f403e6fcd1c61336c24e5882a6550413e3f8448bad34b1b38b253e2d8.jpg differ diff --git a/data/spotlight_reference_images/ref_0051_10355_LLM_Meeting_Decision_Trees_on_Tabular_Data__e8ed3c7e09b0287f1ecdd7f6816dc3fd0e7bec186048c777bf1b0e9cc49fadc8.jpg b/data/spotlight_reference_images/ref_0051_10355_LLM_Meeting_Decision_Trees_on_Tabular_Data__e8ed3c7e09b0287f1ecdd7f6816dc3fd0e7bec186048c777bf1b0e9cc49fadc8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..525b1faf19bea68a5b4c9090a8a7e737ed0e4fe1 Binary files /dev/null and b/data/spotlight_reference_images/ref_0051_10355_LLM_Meeting_Decision_Trees_on_Tabular_Data__e8ed3c7e09b0287f1ecdd7f6816dc3fd0e7bec186048c777bf1b0e9cc49fadc8.jpg differ diff --git a/data/spotlight_reference_images/ref_0052_10520_TrajMamba_An_Efficient_and_Semantic-rich_Vehicle_Trajectory_Pre-training_Model__02d2a7b7aa1ad60cce35445c46fdcb453afa273d8a170ce0abe33ab2c8c6f245.jpg b/data/spotlight_reference_images/ref_0052_10520_TrajMamba_An_Efficient_and_Semantic-rich_Vehicle_Trajectory_Pre-training_Model__02d2a7b7aa1ad60cce35445c46fdcb453afa273d8a170ce0abe33ab2c8c6f245.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0cf8ff564134e92ddd0ced0691bdfe9c7de300c9 --- /dev/null +++ b/data/spotlight_reference_images/ref_0052_10520_TrajMamba_An_Efficient_and_Semantic-rich_Vehicle_Trajectory_Pre-training_Model__02d2a7b7aa1ad60cce35445c46fdcb453afa273d8a170ce0abe33ab2c8c6f245.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:367d893ccf84bd2a4abefd43535b8c317bd1e8ff9d72ab5f08ee30c54bfdc4f3 +size 103631 diff --git a/data/spotlight_reference_images/ref_0053_10738_CALM-PDE_Continuous_and_Adaptive_Convolutions_for_Latent_Space_Modeling_of_Time-dependent_PDEs__075a498871174e6eda4523156efe1ac3fc4b2117ecb6852f0fd4d2fab21397c1.jpg b/data/spotlight_reference_images/ref_0053_10738_CALM-PDE_Continuous_and_Adaptive_Convolutions_for_Latent_Space_Modeling_of_Time-dependent_PDEs__075a498871174e6eda4523156efe1ac3fc4b2117ecb6852f0fd4d2fab21397c1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3dd2e34a55943b456a322a176bdcf36e8ad937d6 Binary files /dev/null and b/data/spotlight_reference_images/ref_0053_10738_CALM-PDE_Continuous_and_Adaptive_Convolutions_for_Latent_Space_Modeling_of_Time-dependent_PDEs__075a498871174e6eda4523156efe1ac3fc4b2117ecb6852f0fd4d2fab21397c1.jpg differ diff --git a/data/spotlight_reference_images/ref_0054_11440_A_Closer_Look_at_Graph_Transformers_Cross-Aggregation_and_Beyond__7b82b794dbb19cd4334009f31fec92816e363cc03a3e2cb6e138b457550a013e.jpg b/data/spotlight_reference_images/ref_0054_11440_A_Closer_Look_at_Graph_Transformers_Cross-Aggregation_and_Beyond__7b82b794dbb19cd4334009f31fec92816e363cc03a3e2cb6e138b457550a013e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99f8ecde2d5f1eea0bdb613b6ddbd9cb63c2422a Binary files /dev/null and b/data/spotlight_reference_images/ref_0054_11440_A_Closer_Look_at_Graph_Transformers_Cross-Aggregation_and_Beyond__7b82b794dbb19cd4334009f31fec92816e363cc03a3e2cb6e138b457550a013e.jpg differ diff --git a/data/spotlight_reference_images/ref_0055_11977_ESCA_Contextualizing_Embodied_Agents_via_Scene-Graph_Generation__0e5ce61c18a6e2bc6119a8b87d407380d0be2097d18c191dc8377eeb77f485c1.jpg b/data/spotlight_reference_images/ref_0055_11977_ESCA_Contextualizing_Embodied_Agents_via_Scene-Graph_Generation__0e5ce61c18a6e2bc6119a8b87d407380d0be2097d18c191dc8377eeb77f485c1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..26f58b9285734b2d2ef8b23ce891a261fdc75cb3 Binary files /dev/null and b/data/spotlight_reference_images/ref_0055_11977_ESCA_Contextualizing_Embodied_Agents_via_Scene-Graph_Generation__0e5ce61c18a6e2bc6119a8b87d407380d0be2097d18c191dc8377eeb77f485c1.jpg differ diff --git a/data/spotlight_reference_images/ref_0056_12716_Partition-Then-Adapt_Combating_Prediction_Bias_for_Reliable_Multi-Modal_Test-Time_Adaptation__4a027fd407718e28e709ab62f53033282bd4c606812da55163e1dd282f0b6afa.jpg b/data/spotlight_reference_images/ref_0056_12716_Partition-Then-Adapt_Combating_Prediction_Bias_for_Reliable_Multi-Modal_Test-Time_Adaptation__4a027fd407718e28e709ab62f53033282bd4c606812da55163e1dd282f0b6afa.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee4001a27c6c1b700f784dc63a257bc4692d2d80 Binary files /dev/null and b/data/spotlight_reference_images/ref_0056_12716_Partition-Then-Adapt_Combating_Prediction_Bias_for_Reliable_Multi-Modal_Test-Time_Adaptation__4a027fd407718e28e709ab62f53033282bd4c606812da55163e1dd282f0b6afa.jpg differ diff --git a/data/spotlight_reference_images/ref_0057_12810_DEXTER_Diffusion-Guided_EXplanations_with_TExtual_Reasoning_for_Vision_Models__9804e1179370803b83e2c51a95654805d588d5c66b128984c9eec7a08b9637ae.jpg b/data/spotlight_reference_images/ref_0057_12810_DEXTER_Diffusion-Guided_EXplanations_with_TExtual_Reasoning_for_Vision_Models__9804e1179370803b83e2c51a95654805d588d5c66b128984c9eec7a08b9637ae.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7d3f6c044ea9610a3c6237effe9733f7f2a227f Binary files /dev/null and b/data/spotlight_reference_images/ref_0057_12810_DEXTER_Diffusion-Guided_EXplanations_with_TExtual_Reasoning_for_Vision_Models__9804e1179370803b83e2c51a95654805d588d5c66b128984c9eec7a08b9637ae.jpg differ diff --git a/data/spotlight_reference_images/ref_0058_13240_A_machine_learning_approach_that_beats_Rubiks_cubes__aec92a7999c868664250d8e9aad60b03dbacabd440355bec73af28c512c9d18a.jpg b/data/spotlight_reference_images/ref_0058_13240_A_machine_learning_approach_that_beats_Rubiks_cubes__aec92a7999c868664250d8e9aad60b03dbacabd440355bec73af28c512c9d18a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dfa4c5a56233f2f5773001c8e43898c8044a0fd7 --- /dev/null +++ b/data/spotlight_reference_images/ref_0058_13240_A_machine_learning_approach_that_beats_Rubiks_cubes__aec92a7999c868664250d8e9aad60b03dbacabd440355bec73af28c512c9d18a.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25c23db5ff710d537cf8c8fd60b1041f03bf3c843f0e3d4a7e0b269752c98e50 +size 137395 diff --git a/data/spotlight_reference_images/ref_0059_13594_Audio_Flamingo_3_Advancing_Audio_Intelligence_with_Fully_Open_Large_Audio_Language_Models__5ef6d6bce7058d36800a1158cd2e8ef95d454146e0b4b9cf0affbc5fc04616a6.jpg b/data/spotlight_reference_images/ref_0059_13594_Audio_Flamingo_3_Advancing_Audio_Intelligence_with_Fully_Open_Large_Audio_Language_Models__5ef6d6bce7058d36800a1158cd2e8ef95d454146e0b4b9cf0affbc5fc04616a6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f89bf2abff53d4f2973d411944b765361c7d3ff Binary files /dev/null and b/data/spotlight_reference_images/ref_0059_13594_Audio_Flamingo_3_Advancing_Audio_Intelligence_with_Fully_Open_Large_Audio_Language_Models__5ef6d6bce7058d36800a1158cd2e8ef95d454146e0b4b9cf0affbc5fc04616a6.jpg differ diff --git a/data/spotlight_reference_images/ref_0060_14126_Deno-IF_Unsupervised_Noisy_Visible_and_Infrared_Image_Fusion_Method__685d5064d5b82a4e2e38976afb4b02e3359ccff154e8231646e76cb16970b7a0.jpg b/data/spotlight_reference_images/ref_0060_14126_Deno-IF_Unsupervised_Noisy_Visible_and_Infrared_Image_Fusion_Method__685d5064d5b82a4e2e38976afb4b02e3359ccff154e8231646e76cb16970b7a0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ffcea7b3c33a78a8c89cca42cd309e9535bbd453 --- /dev/null +++ b/data/spotlight_reference_images/ref_0060_14126_Deno-IF_Unsupervised_Noisy_Visible_and_Infrared_Image_Fusion_Method__685d5064d5b82a4e2e38976afb4b02e3359ccff154e8231646e76cb16970b7a0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7760fc56e9e01f9226dcc923db310d3d320a92be60da13b2dfea68ab305fd0c6 +size 121917 diff --git a/data/spotlight_reference_images/ref_0061_14541_InfMasking_Unleashing_Synergistic_Information_by_Contrastive_Multimodal_Interactions__3a9b359ff8813cdcb42e5f731552b476724081ab26b324d61520dfe760e232c4.jpg b/data/spotlight_reference_images/ref_0061_14541_InfMasking_Unleashing_Synergistic_Information_by_Contrastive_Multimodal_Interactions__3a9b359ff8813cdcb42e5f731552b476724081ab26b324d61520dfe760e232c4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04be9df3bcbf7c36c403804f45bca7b4b88509ba Binary files /dev/null and b/data/spotlight_reference_images/ref_0061_14541_InfMasking_Unleashing_Synergistic_Information_by_Contrastive_Multimodal_Interactions__3a9b359ff8813cdcb42e5f731552b476724081ab26b324d61520dfe760e232c4.jpg differ diff --git a/data/spotlight_reference_images/ref_0062_14625_UFO_A_Unified_Approach_to_Fine-grained_Visual_Perception_via_Open-ended_Language_Interface__7778d47c764c3d39ccf94e9f9eeae95ba728cdfd419af0dc69a51377890c43b8.jpg b/data/spotlight_reference_images/ref_0062_14625_UFO_A_Unified_Approach_to_Fine-grained_Visual_Perception_via_Open-ended_Language_Interface__7778d47c764c3d39ccf94e9f9eeae95ba728cdfd419af0dc69a51377890c43b8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9968755801b135c97345af60b17c9f1c4fc8b2a4 Binary files /dev/null and b/data/spotlight_reference_images/ref_0062_14625_UFO_A_Unified_Approach_to_Fine-grained_Visual_Perception_via_Open-ended_Language_Interface__7778d47c764c3d39ccf94e9f9eeae95ba728cdfd419af0dc69a51377890c43b8.jpg differ diff --git a/data/spotlight_reference_images/ref_0063_14894_DeepDiver_Adaptive_Web-Search_Intensity_Scaling_via_Reinforcement_Learning__eab8f2c5b4fb1f7f8676736444fe2c3a699f7a8cdcdc7bc36bec88306a42b5e6.jpg b/data/spotlight_reference_images/ref_0063_14894_DeepDiver_Adaptive_Web-Search_Intensity_Scaling_via_Reinforcement_Learning__eab8f2c5b4fb1f7f8676736444fe2c3a699f7a8cdcdc7bc36bec88306a42b5e6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a96b5aacf4d2cdd6ac70988d8d873a22b562a3c6 Binary files /dev/null and b/data/spotlight_reference_images/ref_0063_14894_DeepDiver_Adaptive_Web-Search_Intensity_Scaling_via_Reinforcement_Learning__eab8f2c5b4fb1f7f8676736444fe2c3a699f7a8cdcdc7bc36bec88306a42b5e6.jpg differ diff --git a/data/spotlight_reference_images/ref_0064_15032_RepLDM_Reprogramming_Pretrained_Latent_Diffusion_Models_for_High-Quality_High-Efficiency_High-Resolution_Image_Generatio__49f36bb20cf3007bee05a62a443752d47002d114038bc30afeb88c2d5b8e68d2.jpg b/data/spotlight_reference_images/ref_0064_15032_RepLDM_Reprogramming_Pretrained_Latent_Diffusion_Models_for_High-Quality_High-Efficiency_High-Resolution_Image_Generatio__49f36bb20cf3007bee05a62a443752d47002d114038bc30afeb88c2d5b8e68d2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f495f3f9b14b5aaed4dd8c24aa906cbc47760d4f Binary files /dev/null and b/data/spotlight_reference_images/ref_0064_15032_RepLDM_Reprogramming_Pretrained_Latent_Diffusion_Models_for_High-Quality_High-Efficiency_High-Resolution_Image_Generatio__49f36bb20cf3007bee05a62a443752d47002d114038bc30afeb88c2d5b8e68d2.jpg differ diff --git a/data/spotlight_reference_images/ref_0065_15063_Achilles_Heel_of_Mamba_Essential_difficulties_of_the_Mamba_architecture_demonstrated_by_synthetic_data__d33f352255ec1956d98dc3760b5f8fabeb4597fcdad19c4d995bb777afe75be7.jpg b/data/spotlight_reference_images/ref_0065_15063_Achilles_Heel_of_Mamba_Essential_difficulties_of_the_Mamba_architecture_demonstrated_by_synthetic_data__d33f352255ec1956d98dc3760b5f8fabeb4597fcdad19c4d995bb777afe75be7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98ad1773109010cb9d8719cd11e2ec4d14e94e4b Binary files /dev/null and b/data/spotlight_reference_images/ref_0065_15063_Achilles_Heel_of_Mamba_Essential_difficulties_of_the_Mamba_architecture_demonstrated_by_synthetic_data__d33f352255ec1956d98dc3760b5f8fabeb4597fcdad19c4d995bb777afe75be7.jpg differ diff --git a/data/spotlight_reference_images/ref_0066_15204_URDF-Anything_Constructing_Articulated_Objects_with_3D_Multimodal_Language_Model__0b67eeed88846c62fb31c7ebacea97d31f3152992a2189d2861c01ded20e9209.jpg b/data/spotlight_reference_images/ref_0066_15204_URDF-Anything_Constructing_Articulated_Objects_with_3D_Multimodal_Language_Model__0b67eeed88846c62fb31c7ebacea97d31f3152992a2189d2861c01ded20e9209.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f946f84673f835540cfb543f37250bc2706cc7b6 Binary files /dev/null and b/data/spotlight_reference_images/ref_0066_15204_URDF-Anything_Constructing_Articulated_Objects_with_3D_Multimodal_Language_Model__0b67eeed88846c62fb31c7ebacea97d31f3152992a2189d2861c01ded20e9209.jpg differ diff --git a/data/spotlight_reference_images/ref_0067_15363_Neighbor-aware_Contrastive_Disambiguation_for_Cross-Modal_Hashing_with_Redundant_Annotations__f81d44fcdcaf182177cc233b7b31674bc2e41e8f23413c0f9e2334362092a047.jpg b/data/spotlight_reference_images/ref_0067_15363_Neighbor-aware_Contrastive_Disambiguation_for_Cross-Modal_Hashing_with_Redundant_Annotations__f81d44fcdcaf182177cc233b7b31674bc2e41e8f23413c0f9e2334362092a047.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0221bb87037342e36d17412da5242ff61784e39a Binary files /dev/null and b/data/spotlight_reference_images/ref_0067_15363_Neighbor-aware_Contrastive_Disambiguation_for_Cross-Modal_Hashing_with_Redundant_Annotations__f81d44fcdcaf182177cc233b7b31674bc2e41e8f23413c0f9e2334362092a047.jpg differ diff --git a/data/spotlight_reference_images/ref_0068_15521_Advanced_Sign_Language_Video_Generation_with_Compressed_and_Quantized_Multi-Condition_Tokenization__d2d51f25adb78d6a07a2d44eb42a32142ba34d7fee31cc5553880518bc5ac160.jpg b/data/spotlight_reference_images/ref_0068_15521_Advanced_Sign_Language_Video_Generation_with_Compressed_and_Quantized_Multi-Condition_Tokenization__d2d51f25adb78d6a07a2d44eb42a32142ba34d7fee31cc5553880518bc5ac160.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8176bd8c5fe96d8e5bea3b0492e5ea8418806aaf Binary files /dev/null and b/data/spotlight_reference_images/ref_0068_15521_Advanced_Sign_Language_Video_Generation_with_Compressed_and_Quantized_Multi-Condition_Tokenization__d2d51f25adb78d6a07a2d44eb42a32142ba34d7fee31cc5553880518bc5ac160.jpg differ diff --git a/data/spotlight_reference_images/ref_0069_15662_Vgent_Graph-based_Retrieval-Reasoning-Augmented_Generation_For_Long_Video_Understanding__8694c9748eee50b1937d4b0ebdeb004376fc01fe618730f02a4778e83f8fe512.jpg b/data/spotlight_reference_images/ref_0069_15662_Vgent_Graph-based_Retrieval-Reasoning-Augmented_Generation_For_Long_Video_Understanding__8694c9748eee50b1937d4b0ebdeb004376fc01fe618730f02a4778e83f8fe512.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0686502deedbb71e9d8977d620da4f8d89f2fc8f Binary files /dev/null and b/data/spotlight_reference_images/ref_0069_15662_Vgent_Graph-based_Retrieval-Reasoning-Augmented_Generation_For_Long_Video_Understanding__8694c9748eee50b1937d4b0ebdeb004376fc01fe618730f02a4778e83f8fe512.jpg differ diff --git a/data/spotlight_reference_images/ref_0070_15841_Co-Reinforcement_Learning_for_Unified_Multimodal_Understanding_and_Generation__8d1bdeb48a8ecdf31ace6493caea90ec34e8e10428d5b91397cd5531c2b33b09.jpg b/data/spotlight_reference_images/ref_0070_15841_Co-Reinforcement_Learning_for_Unified_Multimodal_Understanding_and_Generation__8d1bdeb48a8ecdf31ace6493caea90ec34e8e10428d5b91397cd5531c2b33b09.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7f6e8d3eb8dc8c44528f5229ec649b8c3b7f4c75 --- /dev/null +++ b/data/spotlight_reference_images/ref_0070_15841_Co-Reinforcement_Learning_for_Unified_Multimodal_Understanding_and_Generation__8d1bdeb48a8ecdf31ace6493caea90ec34e8e10428d5b91397cd5531c2b33b09.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a92ada3a62bf6609266c6d1ca2fa95abadb5fa3f6322515dccb2b443691883b +size 121181 diff --git a/data/spotlight_reference_images/ref_0071_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__0560ecda8f650f7bb97ccd0d707e4acdf264b331fcc46dde86585ac98ae9bea3.jpg b/data/spotlight_reference_images/ref_0071_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__0560ecda8f650f7bb97ccd0d707e4acdf264b331fcc46dde86585ac98ae9bea3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bfc6c0db3e6b0c3fd86c41338418cdaef5fca37a Binary files /dev/null and b/data/spotlight_reference_images/ref_0071_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__0560ecda8f650f7bb97ccd0d707e4acdf264b331fcc46dde86585ac98ae9bea3.jpg differ diff --git a/data/spotlight_reference_images/ref_0072_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__930e52dd2794927e6fb50bae6bad348468e579bae789b8ff335ac8fe17887fc4.jpg b/data/spotlight_reference_images/ref_0072_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__930e52dd2794927e6fb50bae6bad348468e579bae789b8ff335ac8fe17887fc4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1adc04bee41620c3131d91845173e18a1de2413c Binary files /dev/null and b/data/spotlight_reference_images/ref_0072_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__930e52dd2794927e6fb50bae6bad348468e579bae789b8ff335ac8fe17887fc4.jpg differ diff --git a/data/spotlight_reference_images/ref_0073_16455_MonoLift_Learning_3D_Manipulation_Policies_from_Monocular_RGB_via_Distillation__ccab38559cedab2d1c2a8bdc521a798e331b4f8bc7975d196eb56249fe6284fc.jpg b/data/spotlight_reference_images/ref_0073_16455_MonoLift_Learning_3D_Manipulation_Policies_from_Monocular_RGB_via_Distillation__ccab38559cedab2d1c2a8bdc521a798e331b4f8bc7975d196eb56249fe6284fc.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0b823fb5a2fb11c728f2e7e77b200d70bde7e7e2 Binary files /dev/null and b/data/spotlight_reference_images/ref_0073_16455_MonoLift_Learning_3D_Manipulation_Policies_from_Monocular_RGB_via_Distillation__ccab38559cedab2d1c2a8bdc521a798e331b4f8bc7975d196eb56249fe6284fc.jpg differ diff --git a/data/spotlight_reference_images/ref_0074_16584_IA-GGAD_Zero-shot_Generalist_Graph_Anomaly_Detection_via_Invariant_and_Affinity_Learning__2be0842b017b1925d07b25f0276d02ffabc8a00fe4e73cc930b0ee0096fcfd40.jpg b/data/spotlight_reference_images/ref_0074_16584_IA-GGAD_Zero-shot_Generalist_Graph_Anomaly_Detection_via_Invariant_and_Affinity_Learning__2be0842b017b1925d07b25f0276d02ffabc8a00fe4e73cc930b0ee0096fcfd40.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c42a41e516eb6ab8c55254b032c9fb6adb56a40e --- /dev/null +++ b/data/spotlight_reference_images/ref_0074_16584_IA-GGAD_Zero-shot_Generalist_Graph_Anomaly_Detection_via_Invariant_and_Affinity_Learning__2be0842b017b1925d07b25f0276d02ffabc8a00fe4e73cc930b0ee0096fcfd40.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76ac875ee9cf559fc1fc65456d0eeae6c44975188dbad07327e4ebb8628b10d8 +size 108066 diff --git a/data/spotlight_reference_images/ref_0075_16810_SANSA_Unleashing_the_Hidden_Semantics_in_SAM2_for_Few-Shot_Segmentation__a53698d17551dcce397bf6ccb6d8643395e4e45230b5350f60b4402de141081d.jpg b/data/spotlight_reference_images/ref_0075_16810_SANSA_Unleashing_the_Hidden_Semantics_in_SAM2_for_Few-Shot_Segmentation__a53698d17551dcce397bf6ccb6d8643395e4e45230b5350f60b4402de141081d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..235a4534c0a7064829fad3b3199a18d90a85fe61 Binary files /dev/null and b/data/spotlight_reference_images/ref_0075_16810_SANSA_Unleashing_the_Hidden_Semantics_in_SAM2_for_Few-Shot_Segmentation__a53698d17551dcce397bf6ccb6d8643395e4e45230b5350f60b4402de141081d.jpg differ diff --git a/data/spotlight_reference_images/ref_0076_16847_Improving_Bilinear_RNN_with_Closed-loop_Control__346edb980fe2eeef4e3740146417099c45c18677da35edb5d244e90a18dd2b08.jpg b/data/spotlight_reference_images/ref_0076_16847_Improving_Bilinear_RNN_with_Closed-loop_Control__346edb980fe2eeef4e3740146417099c45c18677da35edb5d244e90a18dd2b08.jpg new file mode 100644 index 0000000000000000000000000000000000000000..60b910eea4ad8a5e61d2c941841c3d8190960a5f Binary files /dev/null and b/data/spotlight_reference_images/ref_0076_16847_Improving_Bilinear_RNN_with_Closed-loop_Control__346edb980fe2eeef4e3740146417099c45c18677da35edb5d244e90a18dd2b08.jpg differ diff --git a/data/spotlight_reference_images/ref_0077_16975_Gaussian_Herding_across_Pens_An_Optimal_Transport_Perspective_on_Global_Gaussian_Reduction_for_3DGS__809999b7e8616e629cca34d93bc7b8b75ecba188172a3aae71532d5f8da49a7f.jpg b/data/spotlight_reference_images/ref_0077_16975_Gaussian_Herding_across_Pens_An_Optimal_Transport_Perspective_on_Global_Gaussian_Reduction_for_3DGS__809999b7e8616e629cca34d93bc7b8b75ecba188172a3aae71532d5f8da49a7f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..790030f6843b27b53ec09594da3c6ca002d06cb0 Binary files /dev/null and b/data/spotlight_reference_images/ref_0077_16975_Gaussian_Herding_across_Pens_An_Optimal_Transport_Perspective_on_Global_Gaussian_Reduction_for_3DGS__809999b7e8616e629cca34d93bc7b8b75ecba188172a3aae71532d5f8da49a7f.jpg differ diff --git a/data/spotlight_reference_images/ref_0078_18915_MAESTRO_Adaptive_Sparse_Attention_and_Robust_Learning_for_Multimodal_Dynamic_Time_Series__67404fbbf029c9afb8f8968a7af58d7e984a0b6491776fcd497151bcc2f13bb7.jpg b/data/spotlight_reference_images/ref_0078_18915_MAESTRO_Adaptive_Sparse_Attention_and_Robust_Learning_for_Multimodal_Dynamic_Time_Series__67404fbbf029c9afb8f8968a7af58d7e984a0b6491776fcd497151bcc2f13bb7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa02d5a8f312827620f4c51e81fc54de1b674e94 Binary files /dev/null and b/data/spotlight_reference_images/ref_0078_18915_MAESTRO_Adaptive_Sparse_Attention_and_Robust_Learning_for_Multimodal_Dynamic_Time_Series__67404fbbf029c9afb8f8968a7af58d7e984a0b6491776fcd497151bcc2f13bb7.jpg differ diff --git a/data/spotlight_reference_images/ref_0079_19455_Wide-Horizon_Thinking_and_Simulation-Based_Evaluation_for_Real-World_LLM_Planning_with_Multifaceted_Constraints__198c85b432b1ddbf1afc76ab8c98e057973c4763acbaa0f16a4da51d97460935.jpg b/data/spotlight_reference_images/ref_0079_19455_Wide-Horizon_Thinking_and_Simulation-Based_Evaluation_for_Real-World_LLM_Planning_with_Multifaceted_Constraints__198c85b432b1ddbf1afc76ab8c98e057973c4763acbaa0f16a4da51d97460935.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bdb768e15a061376624426438f83ce64349d16df --- /dev/null +++ b/data/spotlight_reference_images/ref_0079_19455_Wide-Horizon_Thinking_and_Simulation-Based_Evaluation_for_Real-World_LLM_Planning_with_Multifaceted_Constraints__198c85b432b1ddbf1afc76ab8c98e057973c4763acbaa0f16a4da51d97460935.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c1dd2d6cf748ad6c263391d87bf1eab7c08eb61e83935a2dabfc8e506910398 +size 150910 diff --git a/data/spotlight_reference_images/ref_0080_19543_3D_Interaction_Geometric_Pre-training_for_Molecular_Relational_Learning__83a8eaca0dfa5c1c767cf45d51dcd59e0847b56fa3746d382df02fe2c7f8dc8f.jpg b/data/spotlight_reference_images/ref_0080_19543_3D_Interaction_Geometric_Pre-training_for_Molecular_Relational_Learning__83a8eaca0dfa5c1c767cf45d51dcd59e0847b56fa3746d382df02fe2c7f8dc8f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e88295295a754b1e8f859e54634b0a147524fec Binary files /dev/null and b/data/spotlight_reference_images/ref_0080_19543_3D_Interaction_Geometric_Pre-training_for_Molecular_Relational_Learning__83a8eaca0dfa5c1c767cf45d51dcd59e0847b56fa3746d382df02fe2c7f8dc8f.jpg differ diff --git a/data/spotlight_reference_images/ref_0081_19930_OpenBox_Annotate_Any_Bounding_Boxes_in_3D__46114bbc65b0c5dc51006123b8a780a899d670fa419bd45a70045da0164d1561.jpg b/data/spotlight_reference_images/ref_0081_19930_OpenBox_Annotate_Any_Bounding_Boxes_in_3D__46114bbc65b0c5dc51006123b8a780a899d670fa419bd45a70045da0164d1561.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cddb5ec965150d217843184fbbd7b05cd8d8929c Binary files /dev/null and b/data/spotlight_reference_images/ref_0081_19930_OpenBox_Annotate_Any_Bounding_Boxes_in_3D__46114bbc65b0c5dc51006123b8a780a899d670fa419bd45a70045da0164d1561.jpg differ diff --git a/data/spotlight_reference_images/ref_0082_20361_InfiFPO_Implicit_Model_Fusion_via_Preference_Optimization_in_Large_Language_Models__31acf5abaa557c97a77cc1c9abe1392c26234ba8c89a49a135781ba0b2795858.jpg b/data/spotlight_reference_images/ref_0082_20361_InfiFPO_Implicit_Model_Fusion_via_Preference_Optimization_in_Large_Language_Models__31acf5abaa557c97a77cc1c9abe1392c26234ba8c89a49a135781ba0b2795858.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f544c5d1900a8444339c1b438d66fc2e14d3b01d Binary files /dev/null and b/data/spotlight_reference_images/ref_0082_20361_InfiFPO_Implicit_Model_Fusion_via_Preference_Optimization_in_Large_Language_Models__31acf5abaa557c97a77cc1c9abe1392c26234ba8c89a49a135781ba0b2795858.jpg differ diff --git a/data/spotlight_reference_images/ref_0083_20698_RoboScape_Physics-informed_Embodied_World_Model__d4f7d38c49bffcb348a661ab98a561819cda0d19e0d70e7e85afca8a78c6d605.jpg b/data/spotlight_reference_images/ref_0083_20698_RoboScape_Physics-informed_Embodied_World_Model__d4f7d38c49bffcb348a661ab98a561819cda0d19e0d70e7e85afca8a78c6d605.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e144367444ecab0894e7a8c9709a682420cea8fc Binary files /dev/null and b/data/spotlight_reference_images/ref_0083_20698_RoboScape_Physics-informed_Embodied_World_Model__d4f7d38c49bffcb348a661ab98a561819cda0d19e0d70e7e85afca8a78c6d605.jpg differ diff --git a/data/spotlight_reference_images/ref_0084_21254_AutoToM_Scaling_Model-based_Mental_Inference_via_Automated_Agent_Modeling__53e45709689cdb22e79c43986ceb7dd95a89e0537ed690e282906aba317b672b.jpg b/data/spotlight_reference_images/ref_0084_21254_AutoToM_Scaling_Model-based_Mental_Inference_via_Automated_Agent_Modeling__53e45709689cdb22e79c43986ceb7dd95a89e0537ed690e282906aba317b672b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..593d15084e6b369dc91bec76f7a6850ee51e1856 Binary files /dev/null and b/data/spotlight_reference_images/ref_0084_21254_AutoToM_Scaling_Model-based_Mental_Inference_via_Automated_Agent_Modeling__53e45709689cdb22e79c43986ceb7dd95a89e0537ed690e282906aba317b672b.jpg differ diff --git a/data/spotlight_reference_images/ref_0085_22169_Memory-Enhanced_Neural_Solvers_for_Routing_Problems__57ae3c53e263eaed1d5411494d8afa138b9c00c0fcd48b48b00554a0a11aa997.jpg b/data/spotlight_reference_images/ref_0085_22169_Memory-Enhanced_Neural_Solvers_for_Routing_Problems__57ae3c53e263eaed1d5411494d8afa138b9c00c0fcd48b48b00554a0a11aa997.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8fab7f147d92357e02574288cacf7b086843718b Binary files /dev/null and b/data/spotlight_reference_images/ref_0085_22169_Memory-Enhanced_Neural_Solvers_for_Routing_Problems__57ae3c53e263eaed1d5411494d8afa138b9c00c0fcd48b48b00554a0a11aa997.jpg differ diff --git a/data/spotlight_reference_images/ref_0086_22536_3D_Equivariant_Visuomotor_Policy_Learning_via_Spherical_Projection__2857dc21c4b5c9af4a1f6743eafa60560ce1fa225ec43fb36b14a6bc612689c3.jpg b/data/spotlight_reference_images/ref_0086_22536_3D_Equivariant_Visuomotor_Policy_Learning_via_Spherical_Projection__2857dc21c4b5c9af4a1f6743eafa60560ce1fa225ec43fb36b14a6bc612689c3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7d0f0f946062f7faf89f234ff0324b8b4e859767 Binary files /dev/null and b/data/spotlight_reference_images/ref_0086_22536_3D_Equivariant_Visuomotor_Policy_Learning_via_Spherical_Projection__2857dc21c4b5c9af4a1f6743eafa60560ce1fa225ec43fb36b14a6bc612689c3.jpg differ diff --git a/data/spotlight_reference_images/ref_0087_22755_Breaking_the_Batch_Barrier_B3_of_Contrastive_Learning_via_Smart_Batch_Mining__588e6566b5416ccc18d5f5733612cbc3caa0c11fe2e3bc5c57c32c88a9ec2e41.jpg b/data/spotlight_reference_images/ref_0087_22755_Breaking_the_Batch_Barrier_B3_of_Contrastive_Learning_via_Smart_Batch_Mining__588e6566b5416ccc18d5f5733612cbc3caa0c11fe2e3bc5c57c32c88a9ec2e41.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3c33ccfa65bf76040a701ea48af00aa0debc5ab --- /dev/null +++ b/data/spotlight_reference_images/ref_0087_22755_Breaking_the_Batch_Barrier_B3_of_Contrastive_Learning_via_Smart_Batch_Mining__588e6566b5416ccc18d5f5733612cbc3caa0c11fe2e3bc5c57c32c88a9ec2e41.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:540eb7452f27d1024830748917b5df458279e9eaea2385ee8f5168f78815ea75 +size 104342 diff --git a/data/spotlight_reference_images/ref_0088_22815_Fine-grained_List-wise_Alignment_for_Generative_Medication_Recommendation__e9e98a02e9416522c103e1fa907746fe47d308684fb413be315db6aac8417085.jpg b/data/spotlight_reference_images/ref_0088_22815_Fine-grained_List-wise_Alignment_for_Generative_Medication_Recommendation__e9e98a02e9416522c103e1fa907746fe47d308684fb413be315db6aac8417085.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d028798362b5c47bbda267cf4800f2aa89b1306e Binary files /dev/null and b/data/spotlight_reference_images/ref_0088_22815_Fine-grained_List-wise_Alignment_for_Generative_Medication_Recommendation__e9e98a02e9416522c103e1fa907746fe47d308684fb413be315db6aac8417085.jpg differ diff --git a/data/spotlight_reference_images/ref_0089_25264_Uncertain_Knowledge_Graph_Completion_via_Semi-Supervised_Confidence_Distribution_Learning__3792d52f540c8d8f38a2811f7587d39a902406ffa9ea465f4f7aa90d17c6ae6b.jpg b/data/spotlight_reference_images/ref_0089_25264_Uncertain_Knowledge_Graph_Completion_via_Semi-Supervised_Confidence_Distribution_Learning__3792d52f540c8d8f38a2811f7587d39a902406ffa9ea465f4f7aa90d17c6ae6b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee6aad62bd4862c8778f0a411526626ea939c1de Binary files /dev/null and b/data/spotlight_reference_images/ref_0089_25264_Uncertain_Knowledge_Graph_Completion_via_Semi-Supervised_Confidence_Distribution_Learning__3792d52f540c8d8f38a2811f7587d39a902406ffa9ea465f4f7aa90d17c6ae6b.jpg differ diff --git a/data/spotlight_reference_images/ref_0090_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__77016fb2442549ddf0948cbc73665b099807b9060057aa5f23808eca157535e7.jpg b/data/spotlight_reference_images/ref_0090_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__77016fb2442549ddf0948cbc73665b099807b9060057aa5f23808eca157535e7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..087abacb87598aaf82bb3216bc1e9563e60c05ea Binary files /dev/null and b/data/spotlight_reference_images/ref_0090_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__77016fb2442549ddf0948cbc73665b099807b9060057aa5f23808eca157535e7.jpg differ diff --git a/data/spotlight_reference_images/ref_0091_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__3ee1c39cfef34789b84c9ac395142833bb0505590625b927b99365a1726d429b.jpg b/data/spotlight_reference_images/ref_0091_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__3ee1c39cfef34789b84c9ac395142833bb0505590625b927b99365a1726d429b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09759de7abb1bf05a9a7243adf22690f2b04a80a Binary files /dev/null and b/data/spotlight_reference_images/ref_0091_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__3ee1c39cfef34789b84c9ac395142833bb0505590625b927b99365a1726d429b.jpg differ diff --git a/data/spotlight_reference_images/ref_0092_26459_ZeroS_ZeroSum_Linear_Attention_for_Efficient_Transformers__47c8164ce92491496b8a2bcf9fa7ab7edc460fdfd5bd8ef3cf8bab314c81fd4a.jpg b/data/spotlight_reference_images/ref_0092_26459_ZeroS_ZeroSum_Linear_Attention_for_Efficient_Transformers__47c8164ce92491496b8a2bcf9fa7ab7edc460fdfd5bd8ef3cf8bab314c81fd4a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3be2bac78ad160b525430273dfb98ae03ef645cf Binary files /dev/null and b/data/spotlight_reference_images/ref_0092_26459_ZeroS_ZeroSum_Linear_Attention_for_Efficient_Transformers__47c8164ce92491496b8a2bcf9fa7ab7edc460fdfd5bd8ef3cf8bab314c81fd4a.jpg differ diff --git a/data/spotlight_reference_images/ref_0093_26655_Complete_Structure_Guided_Point_Cloud_Completion_via_Cluster-_and_Instance-Level_Contrastive_Learning__d20fe3769e61092c3c117a89910e94568e63136f5bb1bc9c2cb4c647dc5bb03d.jpg b/data/spotlight_reference_images/ref_0093_26655_Complete_Structure_Guided_Point_Cloud_Completion_via_Cluster-_and_Instance-Level_Contrastive_Learning__d20fe3769e61092c3c117a89910e94568e63136f5bb1bc9c2cb4c647dc5bb03d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f21507d2c65916d46a702b0f0f3356272707c3f5 Binary files /dev/null and b/data/spotlight_reference_images/ref_0093_26655_Complete_Structure_Guided_Point_Cloud_Completion_via_Cluster-_and_Instance-Level_Contrastive_Learning__d20fe3769e61092c3c117a89910e94568e63136f5bb1bc9c2cb4c647dc5bb03d.jpg differ diff --git a/data/spotlight_reference_images/ref_0094_26907_Fast_MRI_for_All_Bridging_Access_Gaps_by_Training_without_Raw_Data__b470855022bfded5864733446e130866e7eb600954465a2b6fbccb5d94396efd.jpg b/data/spotlight_reference_images/ref_0094_26907_Fast_MRI_for_All_Bridging_Access_Gaps_by_Training_without_Raw_Data__b470855022bfded5864733446e130866e7eb600954465a2b6fbccb5d94396efd.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09fdf82e0399ad321b9e6c0cc05b01d9fc20d871 Binary files /dev/null and b/data/spotlight_reference_images/ref_0094_26907_Fast_MRI_for_All_Bridging_Access_Gaps_by_Training_without_Raw_Data__b470855022bfded5864733446e130866e7eb600954465a2b6fbccb5d94396efd.jpg differ diff --git a/data/spotlight_reference_images/ref_0095_26919_FUDOKI_Discrete_Flow-based_Unified_Understanding_and_Generation_via_Kinetic-Optimal_Velocities__9c0a452656594ea3134b9cdcb16988663e9015013c42419254bc35661139b69f.jpg b/data/spotlight_reference_images/ref_0095_26919_FUDOKI_Discrete_Flow-based_Unified_Understanding_and_Generation_via_Kinetic-Optimal_Velocities__9c0a452656594ea3134b9cdcb16988663e9015013c42419254bc35661139b69f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7563708024bfcb331c758b88b8ae708bd9e67acb --- /dev/null +++ b/data/spotlight_reference_images/ref_0095_26919_FUDOKI_Discrete_Flow-based_Unified_Understanding_and_Generation_via_Kinetic-Optimal_Velocities__9c0a452656594ea3134b9cdcb16988663e9015013c42419254bc35661139b69f.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5bff2532b01b89041b13da43f4456e21ea54689d824e3fb7aebfe8ac06f0bf05 +size 142000 diff --git a/data/spotlight_reference_images/ref_0096_26975_LogicTree_Improving_Complex_Reasoning_of_LLMs_via_Instantiated_Multi-step_Synthetic_Logical_Data__75918e90d782aa4c0011abbf0fe69a93e2595315a84e5dd3ba23b1cddfb672b5.jpg b/data/spotlight_reference_images/ref_0096_26975_LogicTree_Improving_Complex_Reasoning_of_LLMs_via_Instantiated_Multi-step_Synthetic_Logical_Data__75918e90d782aa4c0011abbf0fe69a93e2595315a84e5dd3ba23b1cddfb672b5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fccdc13d429c420776e95e9bdc0901f4e672127 --- /dev/null +++ b/data/spotlight_reference_images/ref_0096_26975_LogicTree_Improving_Complex_Reasoning_of_LLMs_via_Instantiated_Multi-step_Synthetic_Logical_Data__75918e90d782aa4c0011abbf0fe69a93e2595315a84e5dd3ba23b1cddfb672b5.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76067a4bf2793e78b501d5d328dbdc8ce36f0808f37bd5347e54dd809ca5a513 +size 148412 diff --git a/data/spotlight_reference_images/ref_0097_27132_Learning_Robust_Vision-Language_Models_from_Natural_Latent_Spaces__1c87de8566409b858e4d9bc3229961976739c1c02d52c8afc8f9c78d21a2caf3.jpg b/data/spotlight_reference_images/ref_0097_27132_Learning_Robust_Vision-Language_Models_from_Natural_Latent_Spaces__1c87de8566409b858e4d9bc3229961976739c1c02d52c8afc8f9c78d21a2caf3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a96985cad27abfc7efd2d3d95529b4726fe150bb Binary files /dev/null and b/data/spotlight_reference_images/ref_0097_27132_Learning_Robust_Vision-Language_Models_from_Natural_Latent_Spaces__1c87de8566409b858e4d9bc3229961976739c1c02d52c8afc8f9c78d21a2caf3.jpg differ diff --git a/data/spotlight_reference_images/ref_0098_27155_DexFlyWheel_A_Scalable_and_Self-improving_Data_Generation_Framework_for_Dexterous_Manipulation__6cb5d9f8f05d11ff6e6bf4f69015de5ad79051d577633793092cf0b753f0d1aa.jpg b/data/spotlight_reference_images/ref_0098_27155_DexFlyWheel_A_Scalable_and_Self-improving_Data_Generation_Framework_for_Dexterous_Manipulation__6cb5d9f8f05d11ff6e6bf4f69015de5ad79051d577633793092cf0b753f0d1aa.jpg new file mode 100644 index 0000000000000000000000000000000000000000..19e1bafef75d486828c1220e34a7c88da4314cec --- /dev/null +++ b/data/spotlight_reference_images/ref_0098_27155_DexFlyWheel_A_Scalable_and_Self-improving_Data_Generation_Framework_for_Dexterous_Manipulation__6cb5d9f8f05d11ff6e6bf4f69015de5ad79051d577633793092cf0b753f0d1aa.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:579cb4f2d0e7838d3fd096a3f47430c0db5e6de2aad1071685ffb3c559263fd3 +size 115677 diff --git a/data/spotlight_reference_images/ref_0099_27534_ErrorTrace_A_Black-Box_Traceability_Mechanism_Based_on_Model_Family_Error_Space__3443e7f7bc9975c59b1083ffbc48907922f978304738c48dd66a04e275fa8b34.jpg b/data/spotlight_reference_images/ref_0099_27534_ErrorTrace_A_Black-Box_Traceability_Mechanism_Based_on_Model_Family_Error_Space__3443e7f7bc9975c59b1083ffbc48907922f978304738c48dd66a04e275fa8b34.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c6c4d69d63d0ac5affc96af2dcc9c037305d9f80 Binary files /dev/null and b/data/spotlight_reference_images/ref_0099_27534_ErrorTrace_A_Black-Box_Traceability_Mechanism_Based_on_Model_Family_Error_Space__3443e7f7bc9975c59b1083ffbc48907922f978304738c48dd66a04e275fa8b34.jpg differ diff --git a/data/spotlight_reference_images/ref_0100_28009_Web-Shepherd_Advancing_PRMs_for_Reinforcing_Web_Agents__c6ed4aceca780ae65b05dd769ca4c1745cac4f7f5f1f3178b4223b9eea08d1d5.jpg b/data/spotlight_reference_images/ref_0100_28009_Web-Shepherd_Advancing_PRMs_for_Reinforcing_Web_Agents__c6ed4aceca780ae65b05dd769ca4c1745cac4f7f5f1f3178b4223b9eea08d1d5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1cb25c98a0e095ecb3a40471f0771ff0bc40a71c Binary files /dev/null and b/data/spotlight_reference_images/ref_0100_28009_Web-Shepherd_Advancing_PRMs_for_Reinforcing_Web_Agents__c6ed4aceca780ae65b05dd769ca4c1745cac4f7f5f1f3178b4223b9eea08d1d5.jpg differ diff --git a/data/spotlight_reference_set.json b/data/spotlight_reference_set.json new file mode 100644 index 0000000000000000000000000000000000000000..d6103d8c7ea5323bbd645c5c1a50dcfd089e0dc9 --- /dev/null +++ b/data/spotlight_reference_set.json @@ -0,0 +1,1802 @@ +[ + { + "id": "ref_0001", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: GraphMaster: A hierarchical multi-agent framework for text-attributed graph synthesis. ", + "image_path": "data/spotlight_reference_images/ref_0001_00232_GraphMaster_Automated_Graph_Synthesis_via_LLM_Agents_in_Data-Limited_Environments__fdf13132133da88f7ce9ae4d0a22c29da1f05f75072f95010a29b1392696ea70.jpg", + "paper_title": "GraphMaster: Automated Graph Synthesis via LLM Agents in Data-Limited Environments", + "source_file": "00232_GraphMaster_Automated_Graph_Synthesis_via_LLM_Agents_in_Data-Limited_Environments", + "page_idx": 3, + "section": "3.1 Framework Overview: RAG-Based Multi-Agent Architecture", + "bbox": [ + 174, + 88, + 825, + 265 + ], + "quality_score": 10 + }, + { + "id": "ref_0002", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Overview of our VoxDet. After 2D-to-3D lifting, VoxDet spatially decouples 3D volumes $\\mathbf { V }$ into two task-specific branches, learning different spatial deformations in the densely projected tri-perceptive space. Then, VoxDet regresses a 4D offset field $\\Delta$ towards instance boundaries with $\\mathbf { V } _ { \\mathrm { r e g } }$ , serving for the instance-level aggregation with $\\mathbf { V } _ { \\mathrm { c l s } }$ in the classification branch. ", + "image_path": "data/spotlight_reference_images/ref_0002_00279_VoxDet_Rethinking_3D_Semantic_Scene_Completion_as_Dense_Object_Detection__7b55d87bf0fcf6d787a440d59bf4617e6d73f10f5b1bcc1b45736ad0a7a57911.jpg", + "paper_title": "VoxDet: Rethinking 3D Semantic Scene Completion as Dense Object Detection", + "source_file": "00279_VoxDet_Rethinking_3D_Semantic_Scene_Completion_as_Dense_Object_Detection", + "page_idx": 4, + "section": "4.2 Spatially-decoupled Voxel Encoder", + "bbox": [ + 174, + 89, + 821, + 203 + ], + "quality_score": 10 + }, + { + "id": "ref_0003", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The pipeline of our proposed SQS. In order to adapt the sparse query-based downstream tasks, we design a sparse query-based 3D Gaussian Splatting pre-training paradigm with RGB image and depth as supervision. The pre-trained image encoder can be leveraged during the fine-tuning stage, and we also propose a query interaction module to fully exploit the knowledge encapsulated in the pre-trained queries. Our proposed light-weight pre-training paradigm can be plugged into any sparse query-based downstream tasks to enhance their performance. ", + "image_path": "data/spotlight_reference_images/ref_0003_00491_SQS_Enhancing_Sparse_Perception_Models_via_Query-based_Splatting_in_Autonomous_Driving__f7c6f154dc3e45e2f58f5a9111ebf57ead0d19f9e77340cd3838d881af17a916.jpg", + "paper_title": "SQS: Enhancing Sparse Perception Models via Query-based Splatting in Autonomous Driving", + "source_file": "00491_SQS_Enhancing_Sparse_Perception_Models_via_Query-based_Splatting_in_Autonomous_Driving", + "page_idx": 4, + "section": "3.3 Gaussian Transformer Decoder and Gaussian Queries", + "bbox": [ + 184, + 89, + 816, + 349 + ], + "quality_score": 10 + }, + { + "id": "ref_0004", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The framework of ProtInvTree. (a) The four steps of reward-guided tree searchβ€”Selection, Expansion, Evalution, and Backpropagationβ€”are illustrated on a partial denoising tree. Each node corresponds to a partially denoised subsequence. After a new node is expanded, β€œjumpy” denoising is performed to quickly estimate its value, which is then backpropagated along the path in the tree. (b) Illustration of how a sequence is generated step by step. Masked tokens in the sequence are progressively infilling through a focus-and-grounding mechanism. ", + "image_path": "data/spotlight_reference_images/ref_0004_00691_ProtInvTree_Deliberate_Protein_Inverse_Folding_with_Reward-guided_Tree_Search__713bbbec11cbef0f1d2c8901e17165fa7db3d1fcf6cfa0d4a8b803d2dccb2ca0.jpg", + "paper_title": "ProtInvTree: Deliberate Protein Inverse Folding with Reward-guided Tree Search", + "source_file": "00691_ProtInvTree_Deliberate_Protein_Inverse_Folding_with_Reward-guided_Tree_Search", + "page_idx": 4, + "section": "4.1 Tree-based MDP Formulation", + "bbox": [ + 176, + 92, + 816, + 242 + ], + "quality_score": 10 + }, + { + "id": "ref_0005", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview. Our CoMCTS trains Mulberry with two alternating phases. In top part, CoMCTS searches reasoning paths iteratively, and in each iteration, it utilizes collective knowledge from multiple MLLMs to jointly (a) expand diverse and complementary candidate subsequent reasoning nodes till the end from a given start node, (b) simulate reasoning outcomes, position error candidate nodes and prune them along with their child nodes, (c) backpropagate to update the score and visit count of each reasoning node in a bottom-up manner, and (d) select the leaf reasoning node with the highest UCB value as next start node. In bottom part, we train the model to learn from the reasoning trees constructed by CoMCTS. ", + "image_path": "data/spotlight_reference_images/ref_0005_00738_Mulberry_Empowering_MLLM_with_o1-like_Reasoning_and_Reflection_via_Collective_Monte_Carlo_Tree_Search__7c987fc8cf213eb47a038117cc38e5a170938289a390de4b8d7b6cd88512d505.jpg", + "paper_title": "Mulberry: Empowering MLLM with o1-like Reasoning and Reflection via Collective Monte Carlo Tree Search", + "source_file": "00738_Mulberry_Empowering_MLLM_with_o1-like_Reasoning_and_Reflection_via_Collective_Monte_Carlo_Tree_Search", + "page_idx": 4, + "section": "3.1 CoMCTS for effective reasoning", + "bbox": [ + 189, + 87, + 808, + 340 + ], + "quality_score": 10 + }, + { + "id": "ref_0006", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Overview of our MesaTask Framework. 1) Task-to-Scene Generation (upper-left). Given a task instruction, we extract detailed task information including environment, sub-goals, and task-relevant objects. A structured spatial reasoning chain performs object list completion, interrelation inference, and scene graph construction, which guides the generation of 3D layouts. Final scenes are obtained via 3D asset retrieval. 2) Reasoning Data Construction (bottom). Based on scene graphs and descriptions of our MesaTask-10K dataset, A multimodal LLM is leveraged to produce task instructions, detailed task information, and complete object lists and interrelations. 3) DPO Data Construction (upper right). To enable DPO training, we generate negative examples by randomly perturbing object positions or relations and removing key objects from normal layouts. ", + "image_path": "data/spotlight_reference_images/ref_0006_00981_MesaTask_Towards_Task-Driven_Tabletop_Scene_Generation_via_3D_Spatial_Reasoning__ddce4bdb68a1689579a491b5a31349db83e5046fbb5424a45dc0883d4115e7d5.jpg", + "paper_title": "MesaTask: Towards Task-Driven Tabletop Scene Generation via 3D Spatial Reasoning", + "source_file": "00981_MesaTask_Towards_Task-Driven_Tabletop_Scene_Generation_via_3D_Spatial_Reasoning", + "page_idx": 5, + "section": "4.2 Spatial Reasoning Chain", + "bbox": [ + 181, + 88, + 816, + 353 + ], + "quality_score": 10 + }, + { + "id": "ref_0007", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of OmniSync. A mask-free training paradigm employs timestep-dependent sampling to predict the lip-synchronized targets $V _ { a b }$ . During inference, progressive noise initialization and dynamic spatiotemporal CFG ensure consistent head pose and precise lip synchronization. ", + "image_path": "data/spotlight_reference_images/ref_0007_01003_OmniSync_Towards_Universal_Lip_Synchronization_via_Diffusion_Transformers__28d606ccd79ed54496343219767701efb0f445058d39887c1cf629a800942f77.jpg", + "paper_title": "OmniSync: Towards Universal Lip Synchronization via Diffusion Transformers", + "source_file": "01003_OmniSync_Towards_Universal_Lip_Synchronization_via_Diffusion_Transformers", + "page_idx": 3, + "section": "3.2 Mask-Free Training Paradigm", + "bbox": [ + 173, + 77, + 821, + 362 + ], + "quality_score": 10 + }, + { + "id": "ref_0008", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The overall pipeline of the SRS module. The multivariate time series is processed with Channel Independent strategy, the Selective Patching first adaptively chooses proper patches from all potential candidate patches. Then the Dynamic Reassembly dertermines the order of the selected patches. Both the Selective Patching and Dynamic Reassembly are gradient-based and learnable. Finally, the Adaptive Fusion integrates the embeddings from Conventional Patching and Dynamic Reassembly, adds the position embeddings to construct the final representations. The subsequent backbones can be used directly without changes, so that the SRS module is a modular plugin. ", + "image_path": "data/spotlight_reference_images/ref_0008_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__ea910fb78f4d4027ff7fe9a63cbbc68a7038ee2e9f4250c2f773c631f265b079.jpg", + "paper_title": "Enhancing Time Series Forecasting through Selective Representation Spaces: A Patch Perspective", + "source_file": "01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective", + "page_idx": 3, + "section": "3.1 Structure Overview", + "bbox": [ + 176, + 88, + 820, + 287 + ], + "quality_score": 10 + }, + { + "id": "ref_0009", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: The detailed architecture of the SRS module. The Selective Patching allows sampling with replacement. It scans all the potential patches with stride equals 1, generates $n$ scores for each, then retrieves the patches with max scores in each sampling. Then the Dynamic Reassembly generates scores for selected patches, and sorts them based on the scores to determine the sequence. In the Embedding phase, both the embeddings from the Dynamic Reassembly and Conventional Patching are adaptively fused to form the representations. ", + "image_path": "data/spotlight_reference_images/ref_0009_01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective__4cc6ca3e3fa15065b6a1781e9a7f814d67a46649325289b63c9bea4072020f4c.jpg", + "paper_title": "Enhancing Time Series Forecasting through Selective Representation Spaces: A Patch Perspective", + "source_file": "01041_Enhancing_Time_Series_Forecasting_through_Selective_Representation_Spaces_A_Patch_Perspective", + "page_idx": 4, + "section": "3.2 Selective Patching", + "bbox": [ + 176, + 88, + 821, + 266 + ], + "quality_score": 10 + }, + { + "id": "ref_0010", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 6: Architecture of DiCo, which consists of (b) DiCo Block, (c) Conv Module, and (d) Compact Channel Attention (CCA). DConv denotes depthwise convolution. ", + "image_path": "data/spotlight_reference_images/ref_0010_01112_DiCo_Revitalizing_ConvNets_for_Scalable_and_Efficient_Diffusion_Modeling__589d9f3ec341480c16ec00bf41076999cd0ce6c1526b97e71eb9c8ffe33b1a1b.jpg", + "paper_title": "DiCo: Revitalizing ConvNets for Scalable and Efficient Diffusion Modeling", + "source_file": "01112_DiCo_Revitalizing_ConvNets_for_Scalable_and_Efficient_Diffusion_Modeling", + "page_idx": 5, + "section": "3.2 Network Architecture", + "bbox": [ + 184, + 87, + 823, + 339 + ], + "quality_score": 10 + }, + { + "id": "ref_0011", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: (a) Overview of the Proposed Approach. Rather than performing tensor products over edges by combining node features and distances, E2Former leverages two key concepts: binomial local expansion and Wigner $6 j$ recoupling. The former represents edge directions in terms of node positions, while the latter reorders the sequence of tensor product operations. Together, the computational complexity of the tensor product is reduced from $O ( | \\mathcal { E } | )$ to $O ( | \\nu | )$ . $\\otimes$ denotes the Clebsch-Gorden tensor product, and $\\otimes ^ { 6 j }$ denotes the CG tensor product where each path is parameterized by a weight governed by the Wigner- $6 j$ coefficients. $\\mathbf { ( b ) }$ Illustration of two equivalent ways to couple the tensor product of three representations: sequentially coupling two tensors before the third (left) or reordering the coupling sequence (right), with equivalence established via the Wigner $6 j$ recoupling. ", + "image_path": "data/spotlight_reference_images/ref_0011_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__b501bcad7830654e421726b37ea0d89207d68c72f0f6aa9179fec65e0c71b205.jpg", + "paper_title": "E2Former: An Efficient and Equivariant Transformer with Linear-Scaling Tensor Products", + "source_file": "01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products", + "page_idx": 2, + "section": "2 Background and Preliminaries", + "bbox": [ + 171, + 88, + 821, + 434 + ], + "quality_score": 10 + }, + { + "id": "ref_0012", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 5: Overview of the E2Former architecture. (a) The main network alternates E2Attention blocks with feedforward layers, repeatedly refining node embeddings from a 3D molecular graph. (b) Within each E2Attention block, scalarized queries/keys (via ir2scalar) are combined with distancedependent features (RBF) and convolutions (6j-TP), updating the node embeddings equivariantly. (c) The final readout incorporates atomic types and radial/spherical expansions (RBF, SH) into a gated projection that produces the per-atom output $y _ { i }$ . ", + "image_path": "data/spotlight_reference_images/ref_0012_01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products__fb4694d88a5097ee72a936634a832ced85d11e90079a4fabc3f1b8c28f24e5d6.jpg", + "paper_title": "E2Former: An Efficient and Equivariant Transformer with Linear-Scaling Tensor Products", + "source_file": "01591_E2Former_An_Efficient_and_Equivariant_Transformer_with_Linear-Scaling_Tensor_Products", + "page_idx": 27, + "section": "G Additional Lemmas", + "bbox": [ + 191, + 143, + 810, + 424 + ], + "quality_score": 10 + }, + { + "id": "ref_0013", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of FSDrive. Taking the currently surround images and task instructions as input, MLLM is trained in the form of next token prediction. MLLM predicts the future spatio-temporal CoT, and then generates trajectory based on the current observation and predicted future. ", + "image_path": "data/spotlight_reference_images/ref_0013_01620_FutureSightDrive_Thinking_Visually_with_Spatio-Temporal_CoT_for_Autonomous_Driving__8a4bffe9a69ef0d2bc0ced518bccdb3146d38727d7fc7402a418b6227a78bcfb.jpg", + "paper_title": "FutureSightDrive: Thinking Visually with Spatio-Temporal CoT for Autonomous Driving", + "source_file": "01620_FutureSightDrive_Thinking_Visually_with_Spatio-Temporal_CoT_for_Autonomous_Driving", + "page_idx": 4, + "section": "3.2 Unified pre-training paradigm for visual generation and understanding", + "bbox": [ + 181, + 90, + 820, + 260 + ], + "quality_score": 10 + }, + { + "id": "ref_0014", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The overview of our proposed G-Memory. ", + "image_path": "data/spotlight_reference_images/ref_0014_01659_G-Memory_Tracing_Hierarchical_Memory_for_Multi-Agent_Systems__48772f699bccd9ecf7285d9f2c4af85d34d60b7ee6b2cbd681278611869db12b.jpg", + "paper_title": "G-Memory: Tracing Hierarchical Memory for Multi-Agent Systems", + "source_file": "01659_G-Memory_Tracing_Hierarchical_Memory_for_Multi-Agent_Systems", + "page_idx": 4, + "section": "4 G-Memory", + "bbox": [ + 173, + 88, + 825, + 371 + ], + "quality_score": 10 + }, + { + "id": "ref_0015", + "domain": "Reinforcement Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Mesh-RFT Framework Overview. The pipeline comprises three stages: 1) Mesh Generation Pre-training using an Hourglass AutoRegressive Transformer and a Shape Encoder; 2) Preference Dataset Construction where a pretrained model generates candidate meshes, and a topology-aware score system establishes preference pairs; and 3) Mesh Generation Post-training which employs Mask DPO with reference and policy networks for subsequent refinement. ", + "image_path": "data/spotlight_reference_images/ref_0015_01839_Mesh-RFT_Enhancing_Mesh_Generation_via_Fine-grained_Reinforcement_Fine-Tuning__4d93550a61cdae636652e7cd1ca974c21c7fca1e8eb6eaa6fa2e03100f1d0f68.jpg", + "paper_title": "Mesh-RFT: Enhancing Mesh Generation via Fine-Grained Reinforcement Fine-Tuning", + "source_file": "01839_Mesh-RFT_Enhancing_Mesh_Generation_via_Fine-grained_Reinforcement_Fine-Tuning", + "page_idx": 3, + "section": "3 Method", + "bbox": [ + 174, + 87, + 825, + 359 + ], + "quality_score": 10 + }, + { + "id": "ref_0016", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Framework for representation extraction, neural encoding model, and JNE Computation. a. Extract ANN representations from images using the CLIP image encoder. b. Use the extracted representations in (linear/nonlinear) neural encoding model to predict brain responses to images. c. Compute the Jacobian matrix to represent the mapping relationship between inputs and outputs of the neural encoding model. Further, calculate the mean, sum, and standard deviation of the Jacobian matrix to obtain the JNE metric. ", + "image_path": "data/spotlight_reference_images/ref_0016_01864_Jacobian-Based_Interpretation_of_Nonlinear_Neural_Encoding_Model__c9ac984c977d21aff284dcfbacf7bdfea345cc73096a3f28d624b026654e1740.jpg", + "paper_title": "Jacobian-Based Interpretation of Nonlinear Neural Encoding Model", + "source_file": "01864_Jacobian-Based_Interpretation_of_Nonlinear_Neural_Encoding_Model", + "page_idx": 3, + "section": "2.4 Jacobian-based Nonlinearity Evaluation Index", + "bbox": [ + 178, + 88, + 821, + 244 + ], + "quality_score": 10 + }, + { + "id": "ref_0017", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of OnlineSplatter Pipeline. The input to our framework consists of a stream of RGB images $\\{ V _ { t } \\} _ { t = 0 } ^ { N }$ , where object masks $\\{ M _ { t } \\} _ { t = 0 } ^ { N }$ are generated and applied to remove background on-the-fly using an off-the-shelf online video segmentation (OVS) module running alongside our framework. At each timestep $t$ , OnlineSplatter processes the input frame $V _ { t }$ by first patchifying it into patch tokens. These tokens are then fed into a transformer-based architecture, which directly reasons and outputs pixel-aligned 3D Gaussian representations in a canonical space. Central to our method is object memory, an implicit module based on cross-attention, which is queried and updated at every timestep. This memory enables the incremental reconstruction of the object, consistently refining the object representation $( \\mathbf { G } _ { o b j , t } ^ { 4 N } )$ as new observations arrive in a fully feed-forward manner. ", + "image_path": "data/spotlight_reference_images/ref_0017_02109_OnlineSplatter_Pose-Free_Online_3D_Reconstruction_for_Free-Moving_Objects__abe4e12f0fc9a7487c6c5774f5ead6b391ede9f832960b5ce462ceb786534a0d.jpg", + "paper_title": "OnlineSplatter: Pose-Free Online 3D Reconstruction for Free-Moving Objects", + "source_file": "02109_OnlineSplatter_Pose-Free_Online_3D_Reconstruction_for_Free-Moving_Objects", + "page_idx": 3, + "section": "3.1 OnlineSplatter Pipeline", + "bbox": [ + 174, + 88, + 825, + 287 + ], + "quality_score": 10 + }, + { + "id": "ref_0018", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 4: Diagram of RobustMerge. Tasks are divided into seen and unseen ones. Checkpoints of seen tasks are trained employing the standard individual training and are merged following the pipeline of inter-parameter adaptation. During inference, the merged model is required to both enhance seen tasks and be generalizable to unseen tasks with an unknown distribution. ", + "image_path": "data/spotlight_reference_images/ref_0018_02239_RobustMerge_Parameter-Efficient_Model_Merging_for_MLLMs_with_Direction_Robustness__45b74fc957d305067e6f46f00bc32c9ee0889b7dc7e18b4c46913d263c1d8c16.jpg", + "paper_title": "RobustMerge: Parameter-Efficient Model Merging for MLLMs with Direction Robustness", + "source_file": "02239_RobustMerge_Parameter-Efficient_Model_Merging_for_MLLMs_with_Direction_Robustness", + "page_idx": 4, + "section": "3.2 Motivation and Observation", + "bbox": [ + 192, + 89, + 807, + 314 + ], + "quality_score": 10 + }, + { + "id": "ref_0019", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overall framework of MDReID. MDReID is designed to support retrieval across arbitrary modality combinations. It disentangles features into shared and specific components to boost performance in both matched and mismatched scenarios. Additionally, by leveraging representation orthogonality loss (ROL) and knowledge discrepancy loss (KDL), MDReID refines feature separation and enhances retrieval robustness. ", + "image_path": "data/spotlight_reference_images/ref_0019_02373_MDReID_Modality-Decoupled_Learning_for_Any-to-Any_Multi-Modal_Object_Re-Identification__517a2ed3f7dd16e048d526da7807ac8b1b73cdb062b79021b7047dd0b467ba9a.jpg", + "paper_title": "MDReID: Modality-Decoupled Learning for Any-to-Any Multi-Modal Object Re-Identification", + "source_file": "02373_MDReID_Modality-Decoupled_Learning_for_Any-to-Any_Multi-Modal_Object_Re-Identification", + "page_idx": 3, + "section": "3.1 MDReID: Any-to-any Object ReID", + "bbox": [ + 179, + 93, + 820, + 364 + ], + "quality_score": 10 + }, + { + "id": "ref_0020", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of Our Method. (a) XNOR-based spiking self-attention. We illustrate the computation flow for $\\mathbf { Q }$ and $\\mathbf { K }$ in a PyTorch-style notation. (b) Gray-PE. Position indices differing by $2 ^ { n }$ exhibit a consistent Hamming distance on their Gray code representations. Gray-PE is implemented by concatenating $G ( l )$ along the $D$ dimension on both $\\mathbf { Q }$ and $\\mathbf { K }$ . (c) Log-PE. A preassigned relative distance encoding map $\\mathbf { R } _ { i , j } \\in \\mathbb { N } _ { 0 }$ is added to the original attention map AttnMap. (d) 2D Form of Gray-PE. A 2D RPE is more suitable than the 1D version for image patches, as it captures the spatial relationships more effectively. ", + "image_path": "data/spotlight_reference_images/ref_0020_03077_Toward_Relative_Positional_Encoding_in_Spiking_Transformers__bdb178031ec8d263c3a5388d900e974b8ce39ae5759a6611f688a57e22173fa5.jpg", + "paper_title": "Toward Relative Positional Encoding in Spiking Transformers", + "source_file": "03077_Toward_Relative_Positional_Encoding_in_Spiking_Transformers", + "page_idx": 4, + "section": "3.5 Gray Code", + "bbox": [ + 173, + 87, + 818, + 364 + ], + "quality_score": 10 + }, + { + "id": "ref_0021", + "domain": "Computer Vision", + "diagram_type": "Training Diagram", + "description": "Figure 1: Neural Atlas Graphs - A NAG represents dynamic scenes (a) as a graph of moving 3D planes (one per object/background). Each plane undergoes rigid transformations and encodes viewdependent appearance/transparency using neural fields ${ \\mathcal { F } } ( { \\mathfrak { b } } )$ along a learned trajectory $g _ { i }$ . The planar optical flow $f _ { i }$ models non-rigid motion and parallax, while learning the representation and rendering is done via opacity-weighted ray casting of $C _ { i , t }$ , $\\mathrm { A } _ { i , t }$ using position based $\\mathbf { Z }$ -buffering. ", + "image_path": "data/spotlight_reference_images/ref_0021_03670_Neural_Atlas_Graphs_for_Dynamic_Scene_Decomposition_and_Editing__16f8fc865baed696e798502de56f3b473dbf2b0b6aa3c1286f384de53c524b97.jpg", + "paper_title": "Neural Atlas Graphs for Dynamic Scene Decomposition and Editing", + "source_file": "03670_Neural_Atlas_Graphs_for_Dynamic_Scene_Decomposition_and_Editing", + "page_idx": 3, + "section": "3.2 Image Formation", + "bbox": [ + 173, + 88, + 826, + 256 + ], + "quality_score": 10 + }, + { + "id": "ref_0022", + "domain": "Reinforcement Learning", + "diagram_type": "Flowchart", + "description": "Figure 1: A conceptual illustration of STITCH-OPE, with novel contributions highlighted in orange. A: Behavior data is sliced into partial trajectories of length $w$ . B: The data is fed to a conditional diffusion model taking a $w$ -length sequence of Gaussian noise $\\epsilon$ and state $s _ { t }$ as inputs, and applies the backward diffusion process to predict the behavior trajectory of length $w$ beginning in state $s _ { t }$ . C: To evaluate policies, STITCH-OPE also trains a neural network on the behavior transitions to predict the immediate reward. D: It then applies guided diffusion on the pretrained diffusion model to generate a batch of partial target trajectories of length $w$ , where the guidance function incorporates the score function of the target policy and the behavior policy. E: The guided partial trajectories are stitched end-to-end to produce full-length target trajectories. Finally, the guided trajectories are evaluated using the empirical reward function $\\hat { R } ( s , a )$ , and averaged to estimate the value of the target policy. ", + "image_path": "data/spotlight_reference_images/ref_0022_03671_STITCH-OPE_Trajectory_Stitching_with_Guided_Diffusion_for_Off-Policy_Evaluation__6e9c875dbc74a8b39bc947de3b928f8a29f7c6db9b03d726a62a961ba0c2fdd3.jpg", + "paper_title": "STITCH-OPE: Trajectory Stitching with Guided Diffusion for Off-Policy Evaluation", + "source_file": "03671_STITCH-OPE_Trajectory_Stitching_with_Guided_Diffusion_for_Off-Policy_Evaluation", + "page_idx": 4, + "section": "3.1 Guided Diffusion for Off-Policy Evaluation", + "bbox": [ + 186, + 87, + 818, + 296 + ], + "quality_score": 10 + }, + { + "id": "ref_0023", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of the proposed scMRDR. We employ $\\beta$ -VAE to disentangle omics-specific and omics-shared latent representations, and impose isometric loss and adversarial training as regularization to encourage modality integration and bio-conservation. ", + "image_path": "data/spotlight_reference_images/ref_0023_04013_scMRDR_A_scalable_and_flexible_framework_for_unpaired_single-cell_multi-omics_data_integration__85cde1b5a410b0d3275a5c0fa81dfe69e2c83c485c9917c296502a6485e2f68b.jpg", + "paper_title": "scMRDR: A Scalable and Flexible Framework for Unpaired Single-Cell Multi-Omics Data Integration", + "source_file": "04013_scMRDR_A_scalable_and_flexible_framework_for_unpaired_single-cell_multi-omics_data_integration", + "page_idx": 3, + "section": "3.1 Preliminary: Disentangled VAE", + "bbox": [ + 187, + 89, + 823, + 330 + ], + "quality_score": 10 + }, + { + "id": "ref_0024", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Transformer Copilot Framework. The overall framework comprises three key components: (1) Copilot Model Design, (2) Training Paradigm, and (3) Inference Paradigm. ", + "image_path": "data/spotlight_reference_images/ref_0024_04165_Transformer_Copilot_Learning_from_The_Mistake_Log_in_LLM_Fine-tuning__8d1e804f51825d9760a37b8d1ca027a61deecc5e33fc172f0c1789814527c37e.jpg", + "paper_title": "Transformer Copilot: Learning from The Mistake Log in LLM Fine-tuning", + "source_file": "04165_Transformer_Copilot_Learning_from_The_Mistake_Log_in_LLM_Fine-tuning", + "page_idx": 3, + "section": "3.1 The Copilot Model Design", + "bbox": [ + 176, + 88, + 823, + 248 + ], + "quality_score": 10 + }, + { + "id": "ref_0025", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 4: Overview of the GeRaF framework. (1) Lensless sampling replaces ray-based methods. (2) A neural implicit model predicts geometry, reflectivity, and power. (3) RF volumetric rendering simulates physical signal propagation. (4) Matched filtering produces MF power images (heatmaps). (5) An L2 loss compares the rendered and ground truth power for end-to-end training. ", + "image_path": "data/spotlight_reference_images/ref_0025_04571_GeRaF_Neural_Geometry_Reconstruction_from_Radio_Frequency_Signals__e096c21c76e1eb88c8d865f73e832e8e9246cddec17f62b5d85bc051caa55165.jpg", + "paper_title": "GeRaF: Neural Geometry Reconstruction from Radio Frequency Signals", + "source_file": "04571_GeRaF_Neural_Geometry_Reconstruction_from_Radio_Frequency_Signals", + "page_idx": 4, + "section": "3 Technical Background", + "bbox": [ + 176, + 88, + 825, + 267 + ], + "quality_score": 10 + }, + { + "id": "ref_0026", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: An overview of the proposed HopaDIFF, which integrates two complementary diffusionbased branches, i.e., holistic and partial branches for action segmentation with target-referenced awareness. To improve controllability and segmentation precision, we introduce HP-xLSTM, a cross-input gated module designed for effective exchange between holistic and partial features, and propose a novel Fourier-based conditioning mechanism to inject frequency-domain control signals into the generative process. During training, the two branches are individually supervised using ground-truth action labels and temporal boundary annotations. ", + "image_path": "data/spotlight_reference_images/ref_0026_04647_HopaDIFF_Holistic-Partial_Aware_Fourier_Conditioned_Diffusion_for_Referring_Human_Action_Segmentation_in_Multi-Person_Sc__0e15e7e99b52ccbc157e3ee04a6de2238b23ccd60543102fc2a70eddb12e5e41.jpg", + "paper_title": "HopaDIFF: Holistic-Partial Aware Fourier Conditioned Diffusion for Referring Human Action Segmentation in Multi-Person Scenarios", + "source_file": "04647_HopaDIFF_Holistic-Partial_Aware_Fourier_Conditioned_Diffusion_for_Referring_Human_Action_Segmentation_in_Multi-Person_Sc", + "page_idx": 4, + "section": "4.1 Preliminaries.", + "bbox": [ + 173, + 88, + 825, + 236 + ], + "quality_score": 10 + }, + { + "id": "ref_0027", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of the CSBrain architecture. After EEG signal preprocessing, the Crossscale Spatiotemporal Tokenization (CST) module encodes multi-resolution features within localized temporal windows and brain regions to produce robust, scale-aware tokens. The Structured Sparse Attention (SSA) module then captures long-range dependencies across windows and regions in a structured and efficient manner. CST and SSA are alternately stacked for $L$ layers to progressively integrate cross-scale spatiotemporal dependencies to build unified and robust representations for diverse BCI tasks with varying spatiotemporal scales. Finally, a lightweight task head is appended for reconstruction, classification, or regression. ", + "image_path": "data/spotlight_reference_images/ref_0027_04717_CSBrain_A_Cross-scale_Spatiotemporal_Brain_Foundation_Model_for_EEG_Decoding__327e1ef5f11138cef78e3dd270f09eea700aedb3c5a64cf848b125d13e4e5f08.jpg", + "paper_title": "CSBrain: A Cross-scale Spatiotemporal Brain Foundation Model for EEG Decoding", + "source_file": "04717_CSBrain_A_Cross-scale_Spatiotemporal_Brain_Foundation_Model_for_EEG_Decoding", + "page_idx": 3, + "section": "2.1 EEG Signal Preprocessing", + "bbox": [ + 196, + 92, + 805, + 324 + ], + "quality_score": 10 + }, + { + "id": "ref_0028", + "domain": "Natural Language Processing", + "diagram_type": "Training Diagram", + "description": "Figure 1: Evolution of ST modeling: (a) Traditional coupled STGNN design; (b) Joint ST pretraining in STFMs with tokens from different space and time; (c) FactoST’s factorized paradigm. ", + "image_path": "data/spotlight_reference_images/ref_0028_05129_Learning_to_Factorize_Spatio-Temporal_Foundation_Models__ef11d1775e9863839bc4dfaf8711bf474ef80365303220ba92781b579879e7a5.jpg", + "paper_title": "Learning to Factorize Spatio-Temporal Foundation Models", + "source_file": "05129_Learning_to_Factorize_Spatio-Temporal_Foundation_Models", + "page_idx": 1, + "section": "1 Introduction", + "bbox": [ + 179, + 88, + 821, + 202 + ], + "quality_score": 10 + }, + { + "id": "ref_0029", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The EDELINE world model includes three principal components: (1) A U-Net-like Next-Frame Predictor enhanced by adaptive group normalization and cross-attention mechanisms, (2) A Recurrent Embedding Module built on Mamba architecture for temporal sequence processing, and (3) A Reward/Termination Predictor implemented through linear layers. The EDELINE framework uses shared hidden representations across the components for efficient world model learning. ", + "image_path": "data/spotlight_reference_images/ref_0029_05428_EDELINE_Enhancing_Memory_in_Diffusion-based_World_Models_via_Linear-Time_Sequence_Modeling__57df86687acccd0bad49997d26a4a442d6d09e2381e5a570d1d1e7efd02cf303.jpg", + "paper_title": "EDELINE: Enhancing Memory in Diffusion-based World Models via Linear-Time Sequence Modeling", + "source_file": "05428_EDELINE_Enhancing_Memory_in_Diffusion-based_World_Models_via_Linear-Time_Sequence_Modeling", + "page_idx": 4, + "section": "4 Motivational Experiments", + "bbox": [ + 174, + 88, + 818, + 313 + ], + "quality_score": 10 + }, + { + "id": "ref_0030", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of VIST. VIST, a slow-fast token compression framework, efficiently processes long texts by mimicking human skimming. First, the fast visual path converts long context into images and employs a lightweight vision encoder to capture semantically compact visual features. These features are then integrated into the LLM via cross-attention in the slow cognitive path, allowing LLM to focus on salient content for deeper reasoning. To prioritize informative content in text images, VIST employs Frequency-based Masking on text token embeddings from text tokenizer, suppressing high-frequency but low-information token (e.g., β€œthe” and β€œwith”). Such refined embeddings guide the Resampler in extracting critical semantics from the images. ", + "image_path": "data/spotlight_reference_images/ref_0030_05467_Vision-centric_Token_Compression_in_Large_Language_Model__056bbf059f83c91ea896c610cef2927606ab780d910996e6cdb293dfaca40ddd.jpg", + "paper_title": "Vision-centric Token Compression in Large Language Model", + "source_file": "05467_Vision-centric_Token_Compression_in_Large_Language_Model", + "page_idx": 3, + "section": "3.1 Overall Pipeline", + "bbox": [ + 197, + 89, + 795, + 287 + ], + "quality_score": 10 + }, + { + "id": "ref_0031", + "domain": "Reinforcement Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 4: The workflow of Repo2Run, involving two phases: the build phase and the record phase. The build phase utilizes a dual-environment architecture: the internal environment with five actions for environment building, while the external environment with three actions assists the internal environment. The record phase converts the validated command sequence into a runnable Dockerfile for reconstructing the executable environment. See Appendix A for more examples of these actions. ", + "image_path": "data/spotlight_reference_images/ref_0031_05610_Repo2Run_Automated_Building_Executable_Environment_for_Code_Repository_at_Scale__ea96f359e23ff3f0427d48dd3247314967bb531150d725a7680376b940324680.jpg", + "paper_title": "Repo2Run: Automated Building Executable Environment for Code Repository at Scale", + "source_file": "05610_Repo2Run_Automated_Building_Executable_Environment_for_Code_Repository_at_Scale", + "page_idx": 3, + "section": "3 Repo2Run", + "bbox": [ + 174, + 88, + 825, + 276 + ], + "quality_score": 10 + }, + { + "id": "ref_0032", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of Shallow Diffuse for T2I Diffusion Models. The server scenario (top left) illustrates watermark embedding during generation using CFG, while the user scenario (bottom left) demonstrates post-generation watermark embedding via DDIM inversion. In both scenarios, the watermark is applied within a low-dimensional subspace (top right), where most of the watermark resides in the null space of $J _ { \\theta , t }$ due to its low dimensionality. The adversarial detection (bottom right) highlights the watermark’s robustness, enabling the detector to retrieve the watermark even under adversarial attacks. ", + "image_path": "data/spotlight_reference_images/ref_0032_05774_Shallow_Diffuse_Robust_and_Invisible_Watermarking_through_Low-Dim_Subspaces_in_Diffusion_Models__703f7602f642aa354858ee8cf929888d672a45001a93ac0cb937cd0f4f1b62de.jpg", + "paper_title": "Shallow Diffuse: Robust and Invisible Watermarking through Low-Dim Subspaces in Diffusion Models", + "source_file": "05774_Shallow_Diffuse_Robust_and_Invisible_Watermarking_through_Low-Dim_Subspaces_in_Diffusion_Models", + "page_idx": 3, + "section": "2.2 Local Linearity and Intrinsic Low-Dimensionality in PMP", + "bbox": [ + 178, + 87, + 825, + 265 + ], + "quality_score": 10 + }, + { + "id": "ref_0033", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Algorithm-Hardware Co-Design Diagram of Mozart. Mozart provides an algorithmhardware co-design approach, and we present both the algorithm-level expert clustering & allocation schemes in the left part, and the architecture-level 3.5D chiplet system in the right part. The MoE-LLM parameters are modularized in each decoder layer and mapped to the individual chiplets. ", + "image_path": "data/spotlight_reference_images/ref_0033_05814_Mozart_Modularized_and_Efficient_MoE_Training_on_35D_Wafer-Scale_Chiplet_Architectures__dc6b73dd98f93241717e3b658c319f70ab6ad6188c24a147cd052fb2153d656d.jpg", + "paper_title": "Mozart: Modularized and Efficient MoE Training on 3.5D Wafer-Scale Chiplet Architectures", + "source_file": "05814_Mozart_Modularized_and_Efficient_MoE_Training_on_35D_Wafer-Scale_Chiplet_Architectures", + "page_idx": 3, + "section": "3.3 Efficient All-to-All Communication", + "bbox": [ + 181, + 74, + 818, + 202 + ], + "quality_score": 10 + }, + { + "id": "ref_0034", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: The main framework of our proposed TDLSR. Different shapes signify different samples. ", + "image_path": "data/spotlight_reference_images/ref_0034_06044_Theory-Driven_Label-Specific_Representation_for_Incomplete_Multi-View_Multi-Label_Learning__4d4bbb3c5cd4edb56f73502b7eac2b526f30bfc883b337d949cb38ee0747ee22.jpg", + "paper_title": "Theory-Driven Label-Specific Representation for Incomplete Multi-View Multi-Label Learning", + "source_file": "06044_Theory-Driven_Label-Specific_Representation_for_Incomplete_Multi-View_Multi-Label_Learning", + "page_idx": 2, + "section": "2.1 Problem definition", + "bbox": [ + 174, + 402, + 821, + 587 + ], + "quality_score": 10 + }, + { + "id": "ref_0035", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: EAG3R network. Left: The DUSt3R (MonST3R) architecture with reference and source views processed via ViT encoder-decoder structure. Middle: Our method (only the upstream branch for the reference image is shown), which includes a lightweight event encoder and fuses event and image features with cross-attention. Right: The Retinex-based enhancement module estimates an illumination map and an SNR confidence map to guide adaptive fusion. ", + "image_path": "data/spotlight_reference_images/ref_0035_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__8c0d4df1862409d631870861dc2f047a0cd2572e87267d0d3ea58b6c245408fe.jpg", + "paper_title": "EAG3R: Event-Augmented 3D Geometry Estimation for Dynamic and Extreme-Lighting Scenes", + "source_file": "06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes", + "page_idx": 3, + "section": "3.1 Preliminary", + "bbox": [ + 174, + 87, + 823, + 196 + ], + "quality_score": 10 + }, + { + "id": "ref_0036", + "domain": "Computer Vision", + "diagram_type": "Training Diagram", + "description": "Figure 3: Event-based photometric consistency loss. Harris corners are detected on the input image to define salient patches. Observed brightness increments are computed by integrating event polarities, while predicted increments are synthesized from image gradients and motion. The loss $\\mathcal { L } _ { \\mathrm { e v e n t } }$ measures their alignment. ", + "image_path": "data/spotlight_reference_images/ref_0036_06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes__a50d002b445446ba0c687045ba485e4c96aaf49765198b3f53fb954327df6f4f.jpg", + "paper_title": "EAG3R: Event-Augmented 3D Geometry Estimation for Dynamic and Extreme-Lighting Scenes", + "source_file": "06067_EAG3R_Event-Augmented_3D_Geometry_Estimation_for_Dynamic_and_Extreme-Lighting_Scenes", + "page_idx": 5, + "section": "3.3.1 Event-Based Photometric Consistency Loss", + "bbox": [ + 250, + 89, + 758, + 246 + ], + "quality_score": 10 + }, + { + "id": "ref_0037", + "domain": "Natural Language Processing", + "diagram_type": "Training Diagram", + "description": "Figure 3: Causal Data-Prior Training. At each iteration an index $\\psi _ { i } \\sim \\pi$ is sampled (left), yielding the DGP $P ^ { \\bar { \\psi } _ { i } } ( \\mathbf { X } , T , \\{ Y _ { t } \\} _ { t \\in \\mathcal { T } } , Y )$ . From this DGP we simulate an observational context $\\mathcal { D } _ { \\mathrm { o b s } }$ and a query $\\mathbf { \\rho } ( \\mathbf { x } , t ) $ with its true $\\mu _ { t } ( \\mathbf { x } ; \\psi _ { i } )$ (center). Passing $( \\mathbf { x } , t , \\mathcal { D } _ { \\mathrm { o b s } } )$ through the transformer predicts the CEPO-PPD $q _ { \\theta } ( \\cdot \\mid \\mathbf { x } , t , \\mathcal { D } _ { \\mathrm { o b s } } )$ (in yellow), which is derived from an implicit posterior $\\pi ( \\cdot \\mid \\mathcal { D } _ { \\mathrm { o b s } } )$ that is never explicitly computed $( r i g h t )$ . We train $\\theta$ to minimize the causal data-prior loss (bottom). ", + "image_path": "data/spotlight_reference_images/ref_0037_06507_CausalPFN_Amortized_Causal_Effect_Estimation_via_In-Context_Learning__8c660a9d9ad153e854bc67151e7df9977e2244fa4ce9bd649c2b08b58db2e30c.jpg", + "paper_title": "CausalPFN: Amortized Causal Effect Estimation via In-Context Learning", + "source_file": "06507_CausalPFN_Amortized_Causal_Effect_Estimation_via_In-Context_Learning", + "page_idx": 4, + "section": "3 The Mathematical Framework of CausalPFN", + "bbox": [ + 176, + 88, + 820, + 205 + ], + "quality_score": 10 + }, + { + "id": "ref_0038", + "domain": "Optimization / Theory", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The framework of MRGC, which introduces three complementary graph manifold learning modules into the GC process: constraining the intrinsic dimension, smoothing classification boundaries via manifold curvature limits, and encouraging class manifold decoupling. These modules address the increase in classification complexity within the condensed graph induced by attacks. ", + "image_path": "data/spotlight_reference_images/ref_0038_06527_Robust_Graph_Condensation_via_Classification_Complexity_Mitigation__dedb33c198673910da24a5a2a5794a8228afce42d7b46ff594dab0cac9ee61e0.jpg", + "paper_title": "Robust Graph Condensation via Classification Complexity Mitigation", + "source_file": "06527_Robust_Graph_Condensation_via_Classification_Complexity_Mitigation", + "page_idx": 3, + "section": "3.1 Intrinsic Dimension Manifold Regularization", + "bbox": [ + 173, + 88, + 825, + 309 + ], + "quality_score": 10 + }, + { + "id": "ref_0039", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of the proposed NSG-VD. Given a reference set of real videos $\\{ { \\bf { x } } ^ { r e } \\}$ and a test video ${ \\bf x } ^ { t e }$ , we estimate their spatial gradients $\\nabla _ { \\mathbf { x } } \\log p ( \\mathbf { x } , t )$ and temporal derivatives $\\partial _ { t } \\log p ( \\mathbf { x } , t )$ via a pre-trained diffusion model $s _ { \\theta }$ , from which we derive their Normalized Spatiotemporal Gradients (NSGs) and calculate the MMD between NSG features of real and test videos as a detection metric. ", + "image_path": "data/spotlight_reference_images/ref_0039_06555_Physics-Driven_Spatiotemporal_Modeling_for_AI-Generated_Video_Detection__7960731d2cf65306fb2ccf2b4dc3792ed55197a1c561f04d82e6b487b2023fdf.jpg", + "paper_title": "Physics-Driven Spatiotemporal Modeling for AI-Generated Video Detection", + "source_file": "06555_Physics-Driven_Spatiotemporal_Modeling_for_AI-Generated_Video_Detection", + "page_idx": 3, + "section": "3 Modeling Spatiotemporal Dynamics for AI-Generated Video Detection", + "bbox": [ + 173, + 89, + 825, + 256 + ], + "quality_score": 10 + }, + { + "id": "ref_0040", + "domain": "Computer Vision", + "diagram_type": "Flowchart", + "description": "Figure 3: Concept discovery and labeling process of DANCE. (a) Given a training video, we extract S key clips with length $L$ centered at keyframes identified by a keyframe detection algorithm. We then apply a 2D pose estimator to obtain human pose sequences from these key clips. By clustering all pose sequences across the training set, we cluster them to define each cluster as a motion dynamics concept. (b) For each video, we derive binary motion dynamics concept labels by aggregating the cluster assignment tensor across its key clips. (c) To discover object concepts, we query GPT-4o [19] with prompts containing action class names, yielding a set of object concepts for the dataset. (d) Given a video and the object concept set, we compute concept pseudo labels using a vision-language dual encoder. Specifically, we obtain a concept pseudo label vector by multiplying the object concept embedding matrix with the video embedding vector. We can obtain scene concept labels analogously. ", + "image_path": "data/spotlight_reference_images/ref_0040_06606_Disentangled_Concepts_Speak_Louder_Than_Words_Explainable_Video_Action_Recognition__fe96a76b160d3861e188cfe5511fee2d4f07eada1ebf92ade017048a3362d5b8.jpg", + "paper_title": "Disentangled Concepts Speak Louder Than Words: Explainable Video Action Recognition", + "source_file": "06606_Disentangled_Concepts_Speak_Louder_Than_Words_Explainable_Video_Action_Recognition", + "page_idx": 4, + "section": "3.2.1 Motion Dynamics Concept", + "bbox": [ + 176, + 87, + 825, + 328 + ], + "quality_score": 10 + }, + { + "id": "ref_0041", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Architecture illustration of HYPERION. HYPERION comprises Topological Prototypes Hyperspherical Learning (TP-HSL), Hyperspherical Consistency Noise Calibration (HS-CNC) and Geometric-Aware Hyperspherical Purification (GA-HSP). Best viewed in color and zoom in for details. ", + "image_path": "data/spotlight_reference_images/ref_0041_07858_HYPERION_Fine-Grained_Hypersphere_Alignment_for_Robust_Federated_Graph_Learning__be29a99497ec2dd4d3a8993ce3edc85c87505a1cabfadc2df234b7e326633ebc.jpg", + "paper_title": "HYPERION: Fine-Grained Hypersphere Alignment for Robust Federated Graph Learning", + "source_file": "07858_HYPERION_Fine-Grained_Hypersphere_Alignment_for_Robust_Federated_Graph_Learning", + "page_idx": 3, + "section": "3.1 Framework Overview", + "bbox": [ + 183, + 89, + 802, + 306 + ], + "quality_score": 10 + }, + { + "id": "ref_0042", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Pipeline. Our method consists of Image and Text Encoders for extracting multi-view and text features, Gaussian Decoder for decoding pixel-aligned 3D Gaussians, Unified Query Decoder for decoding pixel-aligned 2D cross-view masks, Mutual Benefit Mechanism for enabling bidirectional promotion between reconstruction and understanding tasks, Pixel-Aligned 2D-to-3D Lifting algorithm for obtaining SIU3R field that enables simultaneous understanding and 3D reconstruction. ", + "image_path": "data/spotlight_reference_images/ref_0042_07877_SIU3R_Simultaneous_Scene_Understanding_and_3D_Reconstruction_Beyond_Feature_Alignment__4e6a5833ae5b980087c2b2a4288f152fec9b55ec42be718174ed81724ea898ac.jpg", + "paper_title": "SIU3R: Simultaneous Scene Understanding and 3D Reconstruction Beyond Feature Alignment", + "source_file": "07877_SIU3R_Simultaneous_Scene_Understanding_and_3D_Reconstruction_Beyond_Feature_Alignment", + "page_idx": 3, + "section": "3.1 Problem Formulation and Pipeline", + "bbox": [ + 205, + 74, + 792, + 213 + ], + "quality_score": 10 + }, + { + "id": "ref_0043", + "domain": "Reinforcement Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of RepoMaster’s autonomous exploration–execution loop and an example demonstration. The agent begins by analyzing the initial context (Step 1) and specifies a file to inspect (Step 2). For efficient viewing, it extracts only the key information from that file (Step 3) and appends it to the context (Step 4). In the next exploration–execution iteration (Step $6 { } 2$ , Step $7 3$ ), the agent uses exploration tools to identify additional relevant files and repeats context-aware code exploration. Once it has gathered enough information, RepoMaster alternates between writing and running β€œ.py” scripts, handling errors, and debugging based on feedback until the task is completed. ", + "image_path": "data/spotlight_reference_images/ref_0043_08772_RepoMaster_Autonomous_Exploration_and_Understanding_of_GitHub_Repositories_for_Complex_Task_Solving__c5102f7309c920d53df2307418ef99304d083aa3f54140e3fa2e55c6b259378b.jpg", + "paper_title": "RepoMaster: Autonomous Exploration and Understanding of GitHub Repositories for Complex Task Solving", + "source_file": "08772_RepoMaster_Autonomous_Exploration_and_Understanding_of_GitHub_Repositories_for_Complex_Task_Solving", + "page_idx": 5, + "section": "3.2.3 Repository Context Initialization", + "bbox": [ + 184, + 89, + 820, + 367 + ], + "quality_score": 10 + }, + { + "id": "ref_0044", + "domain": "Computer Vision", + "diagram_type": "Flowchart", + "description": "Figure 2: Three-stage curation process of MJ-BENCH-VIDEO. ", + "image_path": "data/spotlight_reference_images/ref_0044_08831_MJ-Video_Benchmarking_and_Rewarding_Video_Generation_with_Fine-Grained_Video_Preference__75e635ce2d8e5e0690b91f12cda2422729f5d490691b83e8e3e97e80635a298f.jpg", + "paper_title": "MJ-VIDEO: Benchmarking and Rewarding Video Generation with Fine-Grained Video Preference", + "source_file": "08831_MJ-Video_Benchmarking_and_Rewarding_Video_Generation_with_Fine-Grained_Video_Preference", + "page_idx": 2, + "section": "2.1 Overview of Evaluation Aspect Objectives", + "bbox": [ + 504, + 210, + 818, + 332 + ], + "quality_score": 10 + }, + { + "id": "ref_0045", + "domain": "Machine Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of SparseMVC, a framework designed to address varying sparsity across views. ", + "image_path": "data/spotlight_reference_images/ref_0045_08849_SparseMVC_Probing_Cross-view_Sparsity_Variations_for_Multi-view_Clustering__a2db56ea4b3f2d64de561e0fe461b0b49389f5dea822175ac4ad074f1e2e29c8.jpg", + "paper_title": "SparseMVC: Probing Cross-view Sparsity Variations for Multi-view Clustering", + "source_file": "08849_SparseMVC_Probing_Cross-view_Sparsity_Variations_for_Multi-view_Clustering", + "page_idx": 2, + "section": "3 Method", + "bbox": [ + 176, + 569, + 823, + 737 + ], + "quality_score": 10 + }, + { + "id": "ref_0046", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: Overview of the proposed ATHENA framework. Group-level symbolic utility discovery: Symbolic & semantic constraints library feed an LLM-driven symbolic-optimization engine that iteratively proposes candidate utility functions, scores them with loss $\\mathcal { L } _ { g }$ , and prunes the search via analysis, crossover, and mutation. Red rings in the contour maps illustrate how the feasible solution space shrinks across iterations until the optimal formula $f _ { g } ^ { * }$ is selected. Individual-level semantic adaptation: The optimal group utility $f _ { g } ^ { * }$ seeds a personalized template space. For each individual $i$ , TextGrad computes textual gradients of an individual loss and updates the template $\\mathcal { P } _ { i } ^ { t }$ into a more personalized decision rule $\\mathcal { P } _ { i } ^ { t + 1 }$ . Finally, the optimal $\\mathcal { P } _ { i } ^ { * }$ is used to predict personal decisions. ", + "image_path": "data/spotlight_reference_images/ref_0046_09315_Personalized_Decision_Modeling_Utility_Optimization_or_Textualized-Symbolic_Reasoning__56df140d7973f4f1a6286c7cebec84068dc6828711cea2e455416a0d9d381a99.jpg", + "paper_title": "Personalized Decision Modeling: Utility Optimization or Textualized-Symbolic Reasoning", + "source_file": "09315_Personalized_Decision_Modeling_Utility_Optimization_or_Textualized-Symbolic_Reasoning", + "page_idx": 3, + "section": "3 Methods", + "bbox": [ + 173, + 87, + 825, + 356 + ], + "quality_score": 10 + }, + { + "id": "ref_0047", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Overview of the EGGS framework. We initialize 2D and 3D Gaussians from sparse points obtained via structure-from-motion (SfM) [35, 36]. Their parameters are then jointly optimized using our CUDA-accelerated differentiable hybrid rasterization. To enhance the flexibility of the hybrid representation, Adaptive Type Exchange is introduced to allow each Gaussian to switch between 2D and 3D types during training. Finally, we apply Discrete Wavelet Transform (DWT) [37] and introduce Frequency-Decoupled Optimization to balance geometric accuracy and appearance fidelity. ", + "image_path": "data/spotlight_reference_images/ref_0047_09480_EGGS_Exchangeable_2D3D_Gaussian_Splatting_for_Geometry-Appearance_Balanced_Novel_View_Synthesis__9689645411efcd4495c333462949c56751f3277cd5d1500389c0121fc710deb6.jpg", + "paper_title": "EGGS: Exchangeable 2D/3D Gaussian Splatting for Geometry-Appearance Balanced Novel View Synthesis", + "source_file": "09480_EGGS_Exchangeable_2D3D_Gaussian_Splatting_for_Geometry-Appearance_Balanced_Novel_View_Synthesis", + "page_idx": 3, + "section": "3 Method", + "bbox": [ + 187, + 88, + 807, + 223 + ], + "quality_score": 10 + }, + { + "id": "ref_0048", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: An overview of our method in training and rendering. 4DGT takes a series of monocular frames with poses as input. During training, we subsample the temporal frames at different granularity and use all images in training. We first train 4DGT to predict pixel-aligned Gaussians at coarse resolution in stage one. In stage two training, we pruned a majority of non-activated Gaussians according to the histograms of per-patch activation channels, and densify the Gaussian prediction by increasing the input token samples in both space and time. At inference time, we run the 4DGT network trained after stage two. It can support dense video frames input at high resolution. ", + "image_path": "data/spotlight_reference_images/ref_0048_09629_4DGT_Learning_a_4D_Gaussian_Transformer_Using_Real-World_Monocular_Videos__64516a621163af326843f0152bd0cdb8f798d2df70242271249a95e572c7a300.jpg", + "paper_title": "4DGT: Learning a 4D Gaussian Transformer Using Real-World Monocular Videos", + "source_file": "09629_4DGT_Learning_a_4D_Gaussian_Transformer_Using_Real-World_Monocular_Videos", + "page_idx": 3, + "section": "3.1 Feed-Forward Dynamic Gaussian Prediction", + "bbox": [ + 174, + 88, + 820, + 315 + ], + "quality_score": 10 + }, + { + "id": "ref_0049", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: BevSplat Framework Overview. Query ground image Gaussian primitive initialization involves: (1) A pre-trained depth model for initial 3D positions $( \\mu _ { i } )$ . (2) A ResNet and MLP to predict offsets $( \\Delta \\mathbf { p } _ { k } )$ , scale $( \\mathbf { S } _ { k } )$ , rotation $( \\mathbf { R } _ { k } )$ , and opacity $( O _ { k } )$ . (3) A DPT-fine-tuned DINOv2 for extracting semantic features $( \\mathbf { f } _ { i } )$ and confidences $( c _ { i } )$ , which are then bound to these Gaussians. These feature Gaussians are subsequently rendered into BEV feature and confidence maps. Satellite image features are extracted using an identical DINOv2-DPT backbone (note: weights are shared for KITTI but differ for VIGOR, similar to G2SWeakly [1]). Localization is achieved by matching satellite features with the rendered query BEV features via cosine similarity within a sliding window. ", + "image_path": "data/spotlight_reference_images/ref_0049_09928_BevSplat_Resolving_Height_Ambiguity_via_Feature-Based_Gaussian_Primitives_for_Weakly-Supervised_Cross-View_Localization__a8331d7a8730d2f09ad6fc49f9b8a2d75ad13192be31bd73dcb2c815b8158115.jpg", + "paper_title": "BevSplat: Resolving Height Ambiguity via Feature-Based Gaussian Primitives for Weakly-Supervised Cross-View Localization", + "source_file": "09928_BevSplat_Resolving_Height_Ambiguity_via_Feature-Based_Gaussian_Primitives_for_Weakly-Supervised_Cross-View_Localization", + "page_idx": 3, + "section": "3.1 Geometric Gaussian Primitives Generation", + "bbox": [ + 176, + 84, + 820, + 340 + ], + "quality_score": 10 + }, + { + "id": "ref_0050", + "domain": "Natural Language Processing", + "diagram_type": "Methodology Figure", + "description": "Figure 16: An example of step-by-step CFP generation. ", + "image_path": "data/spotlight_reference_images/ref_0050_10276_MigGPT_Harnessing_Large_Language_Models_for_Automated_Migration_of_Out-of-Tree_Linux_Kernel_Patches_Across_Versions__bf73363f403e6fcd1c61336c24e5882a6550413e3f8448bad34b1b38b253e2d8.jpg", + "paper_title": "MIGGPT: Harnessing Large Language Models for Automated Migration of Out-of-Tree Linux Kernel Patches Across Versions", + "source_file": "10276_MigGPT_Harnessing_Large_Language_Models_for_Automated_Migration_of_Out-of-Tree_Linux_Kernel_Patches_Across_Versions", + "page_idx": 29, + "section": "F.2 Contextual Information", + "bbox": [ + 173, + 305, + 825, + 584 + ], + "quality_score": 10 + }, + { + "id": "ref_0051", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: The DeLTa framework. As shown in the main objective, we calibrate the output of original decision tree experts $F ( x )$ in the direction of β€œerrors” reducing. Subfig (a) describes the process of refining decision tree rules with LLM, and subfig (b) details the refined rule-guided error correction for decision trees. ", + "image_path": "data/spotlight_reference_images/ref_0051_10355_LLM_Meeting_Decision_Trees_on_Tabular_Data__e8ed3c7e09b0287f1ecdd7f6816dc3fd0e7bec186048c777bf1b0e9cc49fadc8.jpg", + "paper_title": "LLM Meeting Decision Trees on Tabular Data", + "source_file": "10355_LLM_Meeting_Decision_Trees_on_Tabular_Data", + "page_idx": 4, + "section": "4.1 LLM-based decision tree rules refinement", + "bbox": [ + 176, + 88, + 828, + 227 + ], + "quality_score": 10 + }, + { + "id": "ref_0052", + "domain": "Machine Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The framework of TrajMamba. ", + "image_path": "data/spotlight_reference_images/ref_0052_10520_TrajMamba_An_Efficient_and_Semantic-rich_Vehicle_Trajectory_Pre-training_Model__02d2a7b7aa1ad60cce35445c46fdcb453afa273d8a170ce0abe33ab2c8c6f245.jpg", + "paper_title": "TrajMamba: An Efficient and Semantic-rich Vehicle Trajectory Pre-training Model", + "source_file": "10520_TrajMamba_An_Efficient_and_Semantic-rich_Vehicle_Trajectory_Pre-training_Model", + "page_idx": 3, + "section": "4.1 Traj-Mamba Encoder", + "bbox": [ + 176, + 87, + 818, + 329 + ], + "quality_score": 10 + }, + { + "id": "ref_0053", + "domain": "Machine Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Encode-process-decode architecture of CALM-PDE. The encoder reduces the spatial dimension and increases the channel dimension. It is based on multiple CALM layers, which perform continuous convolution on learnable query points constrained to an epsilon neighborhood. ", + "image_path": "data/spotlight_reference_images/ref_0053_10738_CALM-PDE_Continuous_and_Adaptive_Convolutions_for_Latent_Space_Modeling_of_Time-dependent_PDEs__075a498871174e6eda4523156efe1ac3fc4b2117ecb6852f0fd4d2fab21397c1.jpg", + "paper_title": "CALM-PDE: Continuous and Adaptive Convolutions for Latent Space Modeling of Time-dependent PDEs", + "source_file": "10738_CALM-PDE_Continuous_and_Adaptive_Convolutions_for_Latent_Space_Modeling_of_Time-dependent_PDEs", + "page_idx": 3, + "section": "3 Background and Preliminaries", + "bbox": [ + 176, + 93, + 820, + 318 + ], + "quality_score": 10 + }, + { + "id": "ref_0054", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "(b) Linear Attention Module. Figure 1: Overview of the proposed GT architecture UGCFormer and its linear attention module. (a) The pipeline of UGCFormer, which incorporates a dual cross-attention (DCA) module. First, two basic elements of graphs (i.e., graph topology and node attributes) are independently processed in their respective spaces utilizing distinct projection layers $f _ { A } ( \\cdot )$ and $f _ { X } ( \\cdot )$ . Next, the dual crossattention (DCA) module with residual connections operates across the topology and attribute spaces, updating each representation by integrating correlated features from the other space. Finally, the two representations are combined to produce the final output representation. (b) Illustration of the proposed efficient cross-attention module, where parameters are shared between the query $( \\mathbf { Q } )$ and key $( \\mathbf { K } )$ , and the representations are computed using linearized attention, given by $\\mathbf { Q } ( \\mathbf { K } ^ { \\top } \\mathbf { V } )$ . ", + "image_path": "data/spotlight_reference_images/ref_0054_11440_A_Closer_Look_at_Graph_Transformers_Cross-Aggregation_and_Beyond__7b82b794dbb19cd4334009f31fec92816e363cc03a3e2cb6e138b457550a013e.jpg", + "paper_title": "A Closer Look at Graph Transformers: Cross-Aggregation and Beyond", + "source_file": "11440_A_Closer_Look_at_Graph_Transformers_Cross-Aggregation_and_Beyond", + "page_idx": 3, + "section": "2.3 Transformers", + "bbox": [ + 171, + 90, + 650, + 256 + ], + "quality_score": 10 + }, + { + "id": "ref_0055", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "ESCA-Video-87K Figure 4: Illustration of the construction of ESCA-Video-87K dataset and the model-driven selfsupervised fine-tuning pipeline of our SGClip model. In addition to videos and their natural language captions, ESCA-Video-87K includes object traces, open-domain concepts, and programmatic specifications for 87K video-caption pairs. The dataset is then used to train SGClip via LASER [34], a neurosymbolic learning procedure based on spatial-temporal alignment. ", + "image_path": "data/spotlight_reference_images/ref_0055_11977_ESCA_Contextualizing_Embodied_Agents_via_Scene-Graph_Generation__0e5ce61c18a6e2bc6119a8b87d407380d0be2097d18c191dc8377eeb77f485c1.jpg", + "paper_title": "ESCA: Contextualizing Embodied Agents via Scene-Graph Generation", + "source_file": "11977_ESCA_Contextualizing_Embodied_Agents_via_Scene-Graph_Generation", + "page_idx": 5, + "section": "3.1 Model Architecture and Inference Time Adaptation", + "bbox": [ + 174, + 101, + 821, + 303 + ], + "quality_score": 10 + }, + { + "id": "ref_0056", + "domain": "Machine Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of PTA. PTA first partitions the online data into two subsets, and jointly evaluates sample importance considering their prediction bias and confidence levels. It then adapts the pretrained model by weighted entropy minimization and multi-modal attention-guided alignment. ", + "image_path": "data/spotlight_reference_images/ref_0056_12716_Partition-Then-Adapt_Combating_Prediction_Bias_for_Reliable_Multi-Modal_Test-Time_Adaptation__4a027fd407718e28e709ab62f53033282bd4c606812da55163e1dd282f0b6afa.jpg", + "paper_title": "Partition-Then-Adapt: Combating Prediction Bias for Reliable Multi-Modal Test-Time Adaptation", + "source_file": "12716_Partition-Then-Adapt_Combating_Prediction_Bias_for_Reliable_Multi-Modal_Test-Time_Adaptation", + "page_idx": 3, + "section": "3.2 Partition and Debiased Reweighting", + "bbox": [ + 174, + 92, + 823, + 255 + ], + "quality_score": 10 + }, + { + "id": "ref_0057", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: DEXTER investigates classifier biases by optimizing a learnable soft prompt to generate text prompts. These text prompts condition a diffusion model to generate images that maximize the activation of the target class in the vision classifier. Images that correctly activate the target class are stored and later captioned for Bias Reasoning. A VLM reasons using these captions to produce human-understandable textual explanations of the model’s decisions and potential biases. More details and clarifications about the pipeline can be found in the Appendices A and B. ", + "image_path": "data/spotlight_reference_images/ref_0057_12810_DEXTER_Diffusion-Guided_EXplanations_with_TExtual_Reasoning_for_Vision_Models__9804e1179370803b83e2c51a95654805d588d5c66b128984c9eec7a08b9637ae.jpg", + "paper_title": "DEXTER: Diffusion-Guided EXplanations with TExtual Reasoning for Vision Models", + "source_file": "12810_DEXTER_Diffusion-Guided_EXplanations_with_TExtual_Reasoning_for_Vision_Models", + "page_idx": 3, + "section": "3.1 Text pipeline", + "bbox": [ + 173, + 88, + 823, + 361 + ], + "quality_score": 10 + }, + { + "id": "ref_0058", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: Proposed ML solution for Rubik’s cube solving: (a) proposed multi-agent solver’s process flow; (b) ResMLP neural network architecture; (c) an example of beam search pathfinding on $3 { \\tt X } 3 { \\tt X } 3$ cube’s graph using $W = 4 0$ . ", + "image_path": "data/spotlight_reference_images/ref_0058_13240_A_machine_learning_approach_that_beats_Rubiks_cubes__aec92a7999c868664250d8e9aad60b03dbacabd440355bec73af28c512c9d18a.jpg", + "paper_title": "A machine learning approach that beats Rubik’s cubes", + "source_file": "13240_A_machine_learning_approach_that_beats_Rubiks_cubes", + "page_idx": 3, + "section": "2 Proposed Machine Learning Approach", + "bbox": [ + 173, + 88, + 826, + 410 + ], + "quality_score": 10 + }, + { + "id": "ref_0059", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of Audio Flamingo 3, AF-Whisper training, and five-stage curriculum training. ", + "image_path": "data/spotlight_reference_images/ref_0059_13594_Audio_Flamingo_3_Advancing_Audio_Intelligence_with_Fully_Open_Large_Audio_Language_Models__5ef6d6bce7058d36800a1158cd2e8ef95d454146e0b4b9cf0affbc5fc04616a6.jpg", + "paper_title": "Audio Flamingo 3: Advancing Audio Intelligence with Fully Open Large Audio Language Models", + "source_file": "13594_Audio_Flamingo_3_Advancing_Audio_Intelligence_with_Fully_Open_Large_Audio_Language_Models", + "page_idx": 3, + "section": "3.1 Audio Flamingo 3 Architecture", + "bbox": [ + 179, + 87, + 816, + 291 + ], + "quality_score": 10 + }, + { + "id": "ref_0060", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overall framework of the unsupervised noisy infrared and visible image fusion method. ", + "image_path": "data/spotlight_reference_images/ref_0060_14126_Deno-IF_Unsupervised_Noisy_Visible_and_Infrared_Image_Fusion_Method__685d5064d5b82a4e2e38976afb4b02e3359ccff154e8231646e76cb16970b7a0.jpg", + "paper_title": "Deno-IF: Unsupervised Noisy Visible and Infrared Image Fusion Method", + "source_file": "14126_Deno-IF_Unsupervised_Noisy_Visible_and_Infrared_Image_Fusion_Method", + "page_idx": 3, + "section": "3.1 Problem Formulation", + "bbox": [ + 174, + 88, + 823, + 382 + ], + "quality_score": 10 + }, + { + "id": "ref_0061", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: The overall pipeline of InfMasking. Given $n$ modalities $X = ( X _ { 1 } , X _ { 2 } , \\ldots , X _ { n } )$ , we augment them to obtain $X ^ { \\prime }$ and $X ^ { \\prime \\prime }$ , which are then encoded independently by modality-specific encoders to extract latent features. These features are processed in three ways: (1) All modality features are concatenated and input into a Transformer block, yielding fused features $Z ^ { \\prime }$ and $Z ^ { \\prime \\prime }$ ; (2) Each modality feature is individually input into a Transformer block, producing unimodal features $Z _ { 1 } , Z _ { 2 } , \\ldots , Z _ { n } ; ( 3 )$ Features of each modality are randomly masked, concatenated, and input into a Transformer block, repeated $k$ times to obtain $Z _ { \\mathrm { m a s k } } ^ { 1 } , Z _ { \\mathrm { m a s k } } ^ { 2 } , . . . , Z _ { \\mathrm { m a s k } } ^ { k }$ . ", + "image_path": "data/spotlight_reference_images/ref_0061_14541_InfMasking_Unleashing_Synergistic_Information_by_Contrastive_Multimodal_Interactions__3a9b359ff8813cdcb42e5f731552b476724081ab26b324d61520dfe760e232c4.jpg", + "paper_title": "InfMasking: Unleashing Synergistic Information by Contrastive Multimodal Interactions", + "source_file": "14541_InfMasking_Unleashing_Synergistic_Information_by_Contrastive_Multimodal_Interactions", + "page_idx": 3, + "section": "2 Preliminary: Contrastive Multimodal Interactions", + "bbox": [ + 178, + 88, + 825, + 383 + ], + "quality_score": 10 + }, + { + "id": "ref_0062", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of our approach. (a) Segmentation modeling: the mask token embedding retrieves similar image features to generate masks (shown with matching colors). (b) Upsampling masks by multiple mask tokens, retrieving more details by more tokens. We use $N { = } 2$ to illustrate while using $N { = } 4$ in implementation. (c) We output open-ended text sequences with textual numbers for detection. ", + "image_path": "data/spotlight_reference_images/ref_0062_14625_UFO_A_Unified_Approach_to_Fine-grained_Visual_Perception_via_Open-ended_Language_Interface__7778d47c764c3d39ccf94e9f9eeae95ba728cdfd419af0dc69a51377890c43b8.jpg", + "paper_title": "UFO: A Unified Approach to Fine-grained Visual Perception via Open-ended Language Interface", + "source_file": "14625_UFO_A_Unified_Approach_to_Fine-grained_Visual_Perception_via_Open-ended_Language_Interface", + "page_idx": 3, + "section": "3.2 Bounding Box Representation", + "bbox": [ + 176, + 569, + 820, + 790 + ], + "quality_score": 10 + }, + { + "id": "ref_0063", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: WebPuzzle pipeline. Above: Candidate Generation: Wiki and open-web pages yield QA pairs via (i) Cross-Page QA and (ii) Riddle pipelines, grouped as Cross-Page QA, Open Riddle, and Wiki Riddle. Below: Difficulty Tagging: Each sample is tagged (easy/medium/hard) for adaptive mixing in RL; DeepDiver is trained on a curated 7k-sample mix. ", + "image_path": "data/spotlight_reference_images/ref_0063_14894_DeepDiver_Adaptive_Web-Search_Intensity_Scaling_via_Reinforcement_Learning__eab8f2c5b4fb1f7f8676736444fe2c3a699f7a8cdcdc7bc36bec88306a42b5e6.jpg", + "paper_title": "DeepDiver: Adaptive Web-Search Intensity Scaling via Reinforcement Learning", + "source_file": "14894_DeepDiver_Adaptive_Web-Search_Intensity_Scaling_via_Reinforcement_Learning", + "page_idx": 3, + "section": "3.1 WebPuzzle", + "bbox": [ + 236, + 75, + 750, + 253 + ], + "quality_score": 10 + }, + { + "id": "ref_0064", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Overview of RepLDM. RepLDM divides the denoising process of a pre-trained LDM into two stages. The first stage leverages the introduced attention guidance to enhance the structural consistency by utilizing a novel training-free self-attention mechanism (TFSA). The second stage iteratively upsamples the latent representation in pixel space to eliminate artifacts. ", + "image_path": "data/spotlight_reference_images/ref_0064_15032_RepLDM_Reprogramming_Pretrained_Latent_Diffusion_Models_for_High-Quality_High-Efficiency_High-Resolution_Image_Generatio__49f36bb20cf3007bee05a62a443752d47002d114038bc30afeb88c2d5b8e68d2.jpg", + "paper_title": "RepLDM: Reprogramming Pretrained Latent Diffusion Models for High-Quality, High-Efficiency, High-Resolution Image Generation", + "source_file": "15032_RepLDM_Reprogramming_Pretrained_Latent_Diffusion_Models_for_High-Quality_High-Efficiency_High-Resolution_Image_Generatio", + "page_idx": 3, + "section": "3.1 Overview of RepLDM", + "bbox": [ + 173, + 88, + 825, + 284 + ], + "quality_score": 10 + }, + { + "id": "ref_0065", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: Overview of Mamba and Transformer Blocks. The green trapezoids represent linear mappings. \"smax\" denotes the softmax function, \"FNN\" stands for feed-forward neural network, and \"LN\" represents layer normalization. The meanings of variables specific to the Mamba block are explained in the main text. ", + "image_path": "data/spotlight_reference_images/ref_0065_15063_Achilles_Heel_of_Mamba_Essential_difficulties_of_the_Mamba_architecture_demonstrated_by_synthetic_data__d33f352255ec1956d98dc3760b5f8fabeb4597fcdad19c4d995bb777afe75be7.jpg", + "paper_title": "Achilles’ Heel of Mamba: Essential difficulties of the Mamba architecture demonstrated by synthetic data", + "source_file": "15063_Achilles_Heel_of_Mamba_Essential_difficulties_of_the_Mamba_architecture_demonstrated_by_synthetic_data", + "page_idx": 3, + "section": "3.2 Difference between Mamba and Transformer", + "bbox": [ + 181, + 224, + 821, + 534 + ], + "quality_score": 10 + }, + { + "id": "ref_0066", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of the URDF-Anything Framework. The pipeline takes a 3D point cloud (from image) and a structured language instruction as input. The 3D MLLM(fine-tuned with LoRA) autoregressively generates symbolic output (kinematic parameters) and $[ S E G ]$ tokens. The embeddings corresponding to the generated $[ S E G ]$ tokens then interact with the point cloud features via a 3D Decoder to perform fine-grained geometric segmentation of the point cloud into individual links. Finally, the jointly predicted kinematic parameters and the segmented geometry are integrated into a functional URDF file, resulting in a complete articulated 3D model ready for physics simulation. ", + "image_path": "data/spotlight_reference_images/ref_0066_15204_URDF-Anything_Constructing_Articulated_Objects_with_3D_Multimodal_Language_Model__0b67eeed88846c62fb31c7ebacea97d31f3152992a2189d2861c01ded20e9209.jpg", + "paper_title": "URDF-Anything: Constructing Articulated Objects with 3D Multimodal Language Model", + "source_file": "15204_URDF-Anything_Constructing_Articulated_Objects_with_3D_Multimodal_Language_Model", + "page_idx": 3, + "section": "3.1 Task Definition", + "bbox": [ + 176, + 90, + 818, + 272 + ], + "quality_score": 10 + }, + { + "id": "ref_0067", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The pipeline of the proposed framework NACD for cross-modal hashing with redundant annotations. NACR refines label confidence by aggregating information from cross-modal neighbors to distinguish true labels from redundant noisy ones. Meanwhile, CRCH constructs reliable positive and negative pairs based on the learned label confidence, which significantly improves robustness against noisy supervision. ", + "image_path": "data/spotlight_reference_images/ref_0067_15363_Neighbor-aware_Contrastive_Disambiguation_for_Cross-Modal_Hashing_with_Redundant_Annotations__f81d44fcdcaf182177cc233b7b31674bc2e41e8f23413c0f9e2334362092a047.jpg", + "paper_title": "Neighbor-aware Contrastive Disambiguation for Cross-Modal Hashing with Redundant Annotations", + "source_file": "15363_Neighbor-aware_Contrastive_Disambiguation_for_Cross-Modal_Hashing_with_Redundant_Annotations", + "page_idx": 3, + "section": "2.2 Learning with Redundant Annotations", + "bbox": [ + 192, + 88, + 802, + 321 + ], + "quality_score": 10 + }, + { + "id": "ref_0068", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Framework of our SignViP for sign language video generation (SLVG). (1) The spoken language text is translated into the multi-condition tokens by Multi-Condition Token Translator. (2) These tokens are decoded by FSQ Autoencoder into multi-condition embeddings, which are equivalent to the embeddings of multiple fine-grained conditions (i.e., fine-grained poses and 3D hands) generated by a multi-condition encoder. (3) The embeddings are injected into Sign Video Diffusion Model to guide the generation of sign language videos. ", + "image_path": "data/spotlight_reference_images/ref_0068_15521_Advanced_Sign_Language_Video_Generation_with_Compressed_and_Quantized_Multi-Condition_Tokenization__d2d51f25adb78d6a07a2d44eb42a32142ba34d7fee31cc5553880518bc5ac160.jpg", + "paper_title": "Advanced Sign Language Video Generation with Compressed and Quantized Multi-Condition Tokenization", + "source_file": "15521_Advanced_Sign_Language_Video_Generation_with_Compressed_and_Quantized_Multi-Condition_Tokenization", + "page_idx": 3, + "section": "3.1 Preliminary", + "bbox": [ + 173, + 88, + 823, + 299 + ], + "quality_score": 10 + }, + { + "id": "ref_0069", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Pipeline of Vgent, a novel framework for long-context video understanding in the proposed graph-based retrieval-reasoning-augmented generation paradigm. It consists of four key stages: (1) Offline video graph construction (Section 3.1): Builds a video graph by extracting knowledge from long videos. (2) Graph-based retrieval (Section 3.2): Retrieves relevant clips based on keywords extracted from the user query. (3) Structured reasoning (Section 3.3): Refines clips using structured queries and aggregates information. (4) Multimodal augmented generation (Section 3.4): Combines refined clips and reasoning results to generate the final response. ", + "image_path": "data/spotlight_reference_images/ref_0069_15662_Vgent_Graph-based_Retrieval-Reasoning-Augmented_Generation_For_Long_Video_Understanding__8694c9748eee50b1937d4b0ebdeb004376fc01fe618730f02a4778e83f8fe512.jpg", + "paper_title": "Vgent: Graph-based Retrieval-Reasoning-Augmented Generation For Long Video Understanding", + "source_file": "15662_Vgent_Graph-based_Retrieval-Reasoning-Augmented_Generation_For_Long_Video_Understanding", + "page_idx": 3, + "section": "3 Method", + "bbox": [ + 173, + 85, + 821, + 337 + ], + "quality_score": 10 + }, + { + "id": "ref_0070", + "domain": "Reinforcement Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of CoRL, a co-reinforcement learning framework to jointly improve the dual capabilities of ULMs. CoRL adopts a two-stage RL procedure, comprising a unified RL stage for joint optimization and a refined RL stage for task-specific enhancement. ", + "image_path": "data/spotlight_reference_images/ref_0070_15841_Co-Reinforcement_Learning_for_Unified_Multimodal_Understanding_and_Generation__8d1bdeb48a8ecdf31ace6493caea90ec34e8e10428d5b91397cd5531c2b33b09.jpg", + "paper_title": "Co-Reinforcement Learning for Unified Multimodal Understanding and Generation", + "source_file": "15841_Co-Reinforcement_Learning_for_Unified_Multimodal_Understanding_and_Generation", + "page_idx": 3, + "section": "3.2 Pilot Exploration", + "bbox": [ + 174, + 87, + 816, + 348 + ], + "quality_score": 10 + }, + { + "id": "ref_0071", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Human Simulation Pipeline. We seed the human-LLM with an extended profile. At each time of day, the human proposes an intention and decomposes it into tasks, aligning with profile traits and temporal dependence on intention/task history. LLM inputs are optimized with Memory Retrieval and Search, and robustness is enhanced via two rounds of Reflexion. This pipeline generates continuous, whole-day intentions and tasks executed in the environment with expressive whole-body motion. See Appendices C and F for details. ", + "image_path": "data/spotlight_reference_images/ref_0071_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__0560ecda8f650f7bb97ccd0d707e4acdf264b331fcc46dde86585ac98ae9bea3.jpg", + "paper_title": "COOPERA: Continual Open-Ended Human-Robot Assistance", + "source_file": "16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance", + "page_idx": 3, + "section": "3.1 Overview", + "bbox": [ + 176, + 88, + 823, + 212 + ], + "quality_score": 10 + }, + { + "id": "ref_0072", + "domain": "Natural Language Processing", + "diagram_type": "Training Diagram", + "description": "Figure 4: Our approach for human assistance. We decouple robot task inference into intention and task inference. By chaining VLM and classifier, the robot selects tasks aligned with the human’s traits and temporal context. It maintains a human profile inferred from collaboration history, which, combined with feedback, optimizes the robot-VLM via prompting and the classifiers via supervised learning. See Appendices D and G for details. ", + "image_path": "data/spotlight_reference_images/ref_0072_16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance__930e52dd2794927e6fb50bae6bad348468e579bae789b8ff335ac8fe17887fc4.jpg", + "paper_title": "COOPERA: Continual Open-Ended Human-Robot Assistance", + "source_file": "16333_COOPERA_Continual_Open-Ended_Human-Robot_Assistance", + "page_idx": 4, + "section": "3.2 Simulating Humans", + "bbox": [ + 179, + 89, + 821, + 241 + ], + "quality_score": 10 + }, + { + "id": "ref_0073", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of the proposed MonoLift framework. The student uses single-view RGB input, while the teacher incorporates estimated depth to guide spatial, temporal, and action learning. Both models are trained end-to-end with shared encoder, Transformer, and policy head for consistent knowledge transfer. To avoid redundancy, action and language tokens, shared between teacher and student, are depicted only in the teacher. ", + "image_path": "data/spotlight_reference_images/ref_0073_16455_MonoLift_Learning_3D_Manipulation_Policies_from_Monocular_RGB_via_Distillation__ccab38559cedab2d1c2a8bdc521a798e331b4f8bc7975d196eb56249fe6284fc.jpg", + "paper_title": "MonoLift: Learning 3D Manipulation Policies from Monocular RGB via Distillation", + "source_file": "16455_MonoLift_Learning_3D_Manipulation_Policies_from_Monocular_RGB_via_Distillation", + "page_idx": 3, + "section": "4.1 Data Flow and Model Architecture", + "bbox": [ + 178, + 90, + 821, + 289 + ], + "quality_score": 10 + }, + { + "id": "ref_0074", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of IA-GGAD. ", + "image_path": "data/spotlight_reference_images/ref_0074_16584_IA-GGAD_Zero-shot_Generalist_Graph_Anomaly_Detection_via_Invariant_and_Affinity_Learning__2be0842b017b1925d07b25f0276d02ffabc8a00fe4e73cc930b0ee0096fcfd40.jpg", + "paper_title": "IA-GGAD: Zero-shot Generalist Graph Anomaly Detection via Invariant and Affinity Learning", + "source_file": "16584_IA-GGAD_Zero-shot_Generalist_Graph_Anomaly_Detection_via_Invariant_and_Affinity_Learning", + "page_idx": 4, + "section": "4.1 Invariant Feature Pool Construction", + "bbox": [ + 209, + 92, + 789, + 390 + ], + "quality_score": 10 + }, + { + "id": "ref_0075", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: Overview of SANSA: Given $k$ annotated reference images and a target image, we construct a pseudo-video by concatenating them, then leverage SAM2 streaming pipeline to process reference frames together with their annotations sequentially. We restructure SAM2 feature space to make its latent semantic structure explicit, enabling mask propagation based on semantic similarity from reference to target. The emergent semantic structure is visualized by the 3D PCA projection of $\\mathcal { F }$ . ", + "image_path": "data/spotlight_reference_images/ref_0075_16810_SANSA_Unleashing_the_Hidden_Semantics_in_SAM2_for_Few-Shot_Segmentation__a53698d17551dcce397bf6ccb6d8643395e4e45230b5350f60b4402de141081d.jpg", + "paper_title": "SANSA: Unleashing the Hidden Semantics in SAM2 for Few-Shot Segmentation", + "source_file": "16810_SANSA_Unleashing_the_Hidden_Semantics_in_SAM2_for_Few-Shot_Segmentation", + "page_idx": 3, + "section": "3 Method", + "bbox": [ + 181, + 87, + 826, + 321 + ], + "quality_score": 10 + }, + { + "id": "ref_0076", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Comba Families. The Mamba-like architecture omits MLP layers, uses multi-value attention, and doubles the model depth. For the hybrid model, we incorporate sliding window attention in flexible proportions to boost the model’s recall ability. The window size is set to the context length, equivalent to softmax attention. ", + "image_path": "data/spotlight_reference_images/ref_0076_16847_Improving_Bilinear_RNN_with_Closed-loop_Control__346edb980fe2eeef4e3740146417099c45c18677da35edb5d244e90a18dd2b08.jpg", + "paper_title": "Improving Bilinear RNNs with Closed-loop Control", + "source_file": "16847_Improving_Bilinear_RNN_with_Closed-loop_Control", + "page_idx": 6, + "section": "3.2 Comba with Chunk-wise Parallel", + "bbox": [ + 178, + 88, + 818, + 308 + ], + "quality_score": 10 + }, + { + "id": "ref_0077", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: An illustration of the proposed GHAP approach. The process begins with full-resolution 3DGS training to obtain initial geometric and appearance features. These Gaussians are then spatially partitioned using a KD-tree and grouped into blocks–analogous to sheep pens. We then perform blockwise Gaussian Mixture Reduction (GMR) to approximate the geometric shape within each block using a much smaller number of Gaussians. This step is analogous to the popular kernel herding method [25]. Finally, a lightweight appearance refinement step further optimizes the appearance feature of the reduced set. This multi-stage pipeline progressively guides the Gaussians in each block–analogous to herding across pens–toward a compact and high-fidelity representation. ", + "image_path": "data/spotlight_reference_images/ref_0077_16975_Gaussian_Herding_across_Pens_An_Optimal_Transport_Perspective_on_Global_Gaussian_Reduction_for_3DGS__809999b7e8616e629cca34d93bc7b8b75ecba188172a3aae71532d5f8da49a7f.jpg", + "paper_title": "Gaussian Herding across Pens: An Optimal Transport Perspective on Global Gaussian Reduction for 3DGS", + "source_file": "16975_Gaussian_Herding_across_Pens_An_Optimal_Transport_Perspective_on_Global_Gaussian_Reduction_for_3DGS", + "page_idx": 3, + "section": "3.1 Probabilistic Scene Representation", + "bbox": [ + 189, + 89, + 808, + 217 + ], + "quality_score": 10 + }, + { + "id": "ref_0078", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of our approach, MAESTRO. Input data from arbitrary combinations of sensing modalities is tokenized using symbolic approximation, where a reserved symbol is used to denote missing modalities. A learnable attention budget gate to allocates modality-wise attention capacity for sparse-attention-based modalityspecific encoders. The resulting modality-specific features are concatenated and combined with modality and positional embeddings, forming a long multimodal sequence, which is processed by a sparse cross-modal multihead-attention layer(s). The resulting tokens are routed through a Sparse Mixture-of-Experts module, enabling dynamic specialization under arbitrary observability conditions. Finally, a classifier maps the aggregated representation to task predictions. ", + "image_path": "data/spotlight_reference_images/ref_0078_18915_MAESTRO_Adaptive_Sparse_Attention_and_Robust_Learning_for_Multimodal_Dynamic_Time_Series__67404fbbf029c9afb8f8968a7af58d7e984a0b6491776fcd497151bcc2f13bb7.jpg", + "paper_title": "MAESTRO : Adaptive Sparse Attention and Robust Learning for Multimodal Dynamic Time Series", + "source_file": "18915_MAESTRO_Adaptive_Sparse_Attention_and_Robust_Learning_for_Multimodal_Dynamic_Time_Series", + "page_idx": 3, + "section": "3.1 Preliminaries and Notations", + "bbox": [ + 240, + 90, + 759, + 398 + ], + "quality_score": 10 + }, + { + "id": "ref_0079", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The overview of the MAoP training and inference process. ", + "image_path": "data/spotlight_reference_images/ref_0079_19455_Wide-Horizon_Thinking_and_Simulation-Based_Evaluation_for_Real-World_LLM_Planning_with_Multifaceted_Constraints__198c85b432b1ddbf1afc76ab8c98e057973c4763acbaa0f16a4da51d97460935.jpg", + "paper_title": "Wide-Horizon Thinking and Simulation-Based Evaluation for Real-World LLM Planning with Multifaceted Constraints", + "source_file": "19455_Wide-Horizon_Thinking_and_Simulation-Based_Evaluation_for_Real-World_LLM_Planning_with_Multifaceted_Constraints", + "page_idx": 3, + "section": "2.2 Wide-Horizon Thinking with Aspect-Aware Guidance", + "bbox": [ + 174, + 93, + 825, + 386 + ], + "quality_score": 10 + }, + { + "id": "ref_0080", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overall Framework: (a) 2D MRL model architecture (Section 3.2). (b) Virtual interaction geometry construction (Section 4.1). (c) $S E ( 3 )$ -Invariant Global Geometry Learning (Section 4.2.1). (d) $S E ( 3 )$ -Equivariant Local Relative Geometry Learning (Section 4.2.2). ", + "image_path": "data/spotlight_reference_images/ref_0080_19543_3D_Interaction_Geometric_Pre-training_for_Molecular_Relational_Learning__83a8eaca0dfa5c1c767cf45d51dcd59e0847b56fa3746d382df02fe2c7f8dc8f.jpg", + "paper_title": "3D Interaction Geometric Pre-training for Molecular Relational Learning", + "source_file": "19543_3D_Interaction_Geometric_Pre-training_for_Molecular_Relational_Learning", + "page_idx": 3, + "section": "3.2 2D MRL Model Architecture", + "bbox": [ + 191, + 88, + 807, + 330 + ], + "quality_score": 10 + }, + { + "id": "ref_0081", + "domain": "Computer Vision", + "diagram_type": "Methodology Figure", + "description": "Figure 5: Handling Static & Rigid Instances. (a) We filter noisy points in the aggregated static point clouds via vertex-level voting on the reconstructed surface, producing $\\mathcal { F } _ { \\mathrm { r e f } } ^ { S , ( 2 ) }$ and $\\mathbf { S } _ { \\mathrm { r e f } }$ . (b) We then adjust the bounding box using surface normals and statistical priors, and select the final box based on 2D IoU between projected boxes and Grounding DINO [22] boxes. ", + "image_path": "data/spotlight_reference_images/ref_0081_19930_OpenBox_Annotate_Any_Bounding_Boxes_in_3D__46114bbc65b0c5dc51006123b8a780a899d670fa419bd45a70045da0164d1561.jpg", + "paper_title": "OpenBox: Annotate Any Bounding Boxes in 3D", + "source_file": "19930_OpenBox_Annotate_Any_Bounding_Boxes_in_3D", + "page_idx": 5, + "section": "3.2 Adaptive 3D Bounding Box Generation", + "bbox": [ + 178, + 89, + 818, + 251 + ], + "quality_score": 10 + }, + { + "id": "ref_0082", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: Overview of InfiFPO for implicit model fusion. We compute probabilities for preferred $( \\pmb { y } _ { w } )$ and dispreferred $( \\pmb { y } _ { l } )$ responses using both pivot and source models. Following length normalization and probability clipping, we identify the source model with the maximum normalized probability difference from the pivot model for fusion and preference alignment. ", + "image_path": "data/spotlight_reference_images/ref_0082_20361_InfiFPO_Implicit_Model_Fusion_via_Preference_Optimization_in_Large_Language_Models__31acf5abaa557c97a77cc1c9abe1392c26234ba8c89a49a135781ba0b2795858.jpg", + "paper_title": "InfiFPO: Implicit Model Fusion via Preference Optimization in Large Language Models", + "source_file": "20361_InfiFPO_Implicit_Model_Fusion_via_Preference_Optimization_in_Large_Language_Models", + "page_idx": 3, + "section": "3.1 FuseRLHF: RLHF for Implicit Model Fusion", + "bbox": [ + 181, + 92, + 813, + 267 + ], + "quality_score": 10 + }, + { + "id": "ref_0083", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of the physics-informed world model, where physical knowledge is integrated through joint learning of temporal depth estimation and adaptively sampled keypoint dynamics. ", + "image_path": "data/spotlight_reference_images/ref_0083_20698_RoboScape_Physics-informed_Embodied_World_Model__d4f7d38c49bffcb348a661ab98a561819cda0d19e0d70e7e85afca8a78c6d605.jpg", + "paper_title": "RoboScape: Physics-informed Embodied World Model", + "source_file": "20698_RoboScape_Physics-informed_Embodied_World_Model", + "page_idx": 3, + "section": "2.3 RoboScape: A Physics-informed Embodied World Model", + "bbox": [ + 184, + 85, + 805, + 376 + ], + "quality_score": 10 + }, + { + "id": "ref_0084", + "domain": "Reinforcement Learning", + "diagram_type": "Methodology Figure", + "description": "Figure 3: (a) Given an agent model, AutoToM samples hypotheses for each latent variable $\\mathrm { \\Sigma } _ { o } t$ and $b ^ { t }$ in this example), remove spurious hypotheses, and conduct Bayesian inference based on estimated local conditionals. (b) Given any ToM inference problem, AutoToM refines the agent model by alternating between variable adjustment (introducing belief in this example) and timestep adjustment. ", + "image_path": "data/spotlight_reference_images/ref_0084_21254_AutoToM_Scaling_Model-based_Mental_Inference_via_Automated_Agent_Modeling__53e45709689cdb22e79c43986ceb7dd95a89e0537ed690e282906aba317b672b.jpg", + "paper_title": "AutoToM: Scaling Model-based Mental Inference via Automated Agent Modeling", + "source_file": "21254_AutoToM_Scaling_Model-based_Mental_Inference_via_Automated_Agent_Modeling", + "page_idx": 4, + "section": "(a) AutoToM constructs appropriate agent models tailored to different scenarios", + "bbox": [ + 173, + 88, + 826, + 236 + ], + "quality_score": 10 + }, + { + "id": "ref_0085", + "domain": "Reinforcement Learning", + "diagram_type": "Flowchart", + "description": "Figure 2: MEMENTO uses a memory to adapt neural solvers at inference time. When taking a decision, data from similar states is retrieved and prepared (1,2), then processed by a MLP to derive correction logits for each action (3). Summing the original and new logits enables to update the action distribution. The resulting policy is then rolled out (4), and transitions’ data is stored in a memory (5,6), including node visited, action taken, log probability, and return obtained. ", + "image_path": "data/spotlight_reference_images/ref_0085_22169_Memory-Enhanced_Neural_Solvers_for_Routing_Problems__57ae3c53e263eaed1d5411494d8afa138b9c00c0fcd48b48b00554a0a11aa997.jpg", + "paper_title": "Memory-Enhanced Neural Solvers for Routing Problems", + "source_file": "22169_Memory-Enhanced_Neural_Solvers_for_Routing_Problems", + "page_idx": 3, + "section": "3.2 MEMENTO", + "bbox": [ + 196, + 133, + 799, + 333 + ], + "quality_score": 10 + }, + { + "id": "ref_0086", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Overview of Image-to-Sphere Policy (ISP) (a) An SO(3)-equivariant observation encoder extracts features from the RGB input, projects them onto the sphere, and applies an equivariance correction using the gripper orientation $R _ { x }$ to account for the camera’s dynamic viewpoint (red arrow). The corrected spherical signal $\\Phi _ { \\mathrm { c o r r } } ( x )$ is then processed by spherical convolution layers to extract SO(3) signals. Proprioceptive inputs are embedded via equivariant linear layers. Both image and proprioceptive features are represented as a set of Fourier coefficients $c _ { \\ell }$ on $\\mathrm { S O } ( 3 )$ and fused (yellow block). (b) The encoded spherical signals are transformed back to the spatial domain via inverse Fourier transform, sampling finite group elements as the conditioning vector for SO(3)-equivariant denoising. The noisy action sequence is processed in the same way, through equivariant linear layers and projected onto the same group elements. ", + "image_path": "data/spotlight_reference_images/ref_0086_22536_3D_Equivariant_Visuomotor_Policy_Learning_via_Spherical_Projection__2857dc21c4b5c9af4a1f6743eafa60560ce1fa225ec43fb36b14a6bc612689c3.jpg", + "paper_title": "3D Equivariant Visuomotor Policy Learning via Spherical Projection", + "source_file": "22536_3D_Equivariant_Visuomotor_Policy_Learning_via_Spherical_Projection", + "page_idx": 3, + "section": "3.4 Problem formulation", + "bbox": [ + 178, + 89, + 823, + 319 + ], + "quality_score": 10 + }, + { + "id": "ref_0087", + "domain": "Graph Learning", + "diagram_type": "Training Diagram", + "description": "Figure 1: The batch mining mechanism of B3. Initially, a teacher model generates a rank matrix $R$ over the training set, indicating potential negative relationships. From these rankings (specifically ranks in the range ${ \\bar { \\boldsymbol { \\mathrm { J } } } } { \\boldsymbol { p } } : { \\boldsymbol { p } } + m { \\bar { \\boldsymbol { \\mathrm { J } } } }$ for each query), a undirected sparse preference graph $S$ is constructed. Then, METIS clustering is applied to identify communities of mutually strong negatives. Finally, diverse training batches of size |B| are formed by sampling examples from $| B | / K$ distinct communities. ", + "image_path": "data/spotlight_reference_images/ref_0087_22755_Breaking_the_Batch_Barrier_B3_of_Contrastive_Learning_via_Smart_Batch_Mining__588e6566b5416ccc18d5f5733612cbc3caa0c11fe2e3bc5c57c32c88a9ec2e41.jpg", + "paper_title": "Breaking the Batch Barrier (B3) of Contrastive Learning via Smart Batch Mining", + "source_file": "22755_Breaking_the_Batch_Barrier_B3_of_Contrastive_Learning_via_Smart_Batch_Mining", + "page_idx": 3, + "section": "3.1 Batch Selection", + "bbox": [ + 186, + 87, + 810, + 412 + ], + "quality_score": 10 + }, + { + "id": "ref_0088", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 4: Overview of patient representation construction. ", + "image_path": "data/spotlight_reference_images/ref_0088_22815_Fine-grained_List-wise_Alignment_for_Generative_Medication_Recommendation__e9e98a02e9416522c103e1fa907746fe47d308684fb413be315db6aac8417085.jpg", + "paper_title": "Fine-grained List-wise Alignment for Generative Medication Recommendation", + "source_file": "22815_Fine-grained_List-wise_Alignment_for_Generative_Medication_Recommendation", + "page_idx": 6, + "section": "4.3 Two-stage Recommendation Framework", + "bbox": [ + 179, + 88, + 823, + 237 + ], + "quality_score": 10 + }, + { + "id": "ref_0089", + "domain": "Graph Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: (a) The overview of ssCDL; (b) The framework of CDL-RL and PCDG. ", + "image_path": "data/spotlight_reference_images/ref_0089_25264_Uncertain_Knowledge_Graph_Completion_via_Semi-Supervised_Confidence_Distribution_Learning__3792d52f540c8d8f38a2811f7587d39a902406ffa9ea465f4f7aa90d17c6ae6b.jpg", + "paper_title": "Uncertain Knowledge Graph Completion via Semi-Supervised Confidence Distribution Learning", + "source_file": "25264_Uncertain_Knowledge_Graph_Completion_via_Semi-Supervised_Confidence_Distribution_Learning", + "page_idx": 3, + "section": "4.1 Overview", + "bbox": [ + 179, + 512, + 823, + 676 + ], + "quality_score": 10 + }, + { + "id": "ref_0090", + "domain": "Optimization / Theory", + "diagram_type": "Methodology Figure", + "description": "Figure 1: An illustration of a 4-bit multiplier with AND-gate based PPG. ", + "image_path": "data/spotlight_reference_images/ref_0090_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__77016fb2442549ddf0948cbc73665b099807b9060057aa5f23808eca157535e7.jpg", + "paper_title": "High-Performance Arithmetic Circuit Optimization via Differentiable Architecture Search", + "source_file": "25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search", + "page_idx": 2, + "section": "2 Preliminary: Arithmetic Circuit Optimization", + "bbox": [ + 191, + 85, + 813, + 234 + ], + "quality_score": 10 + }, + { + "id": "ref_0091", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 4: Overview of our proposed ARITH-DAS framework. ", + "image_path": "data/spotlight_reference_images/ref_0091_25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search__3ee1c39cfef34789b84c9ac395142833bb0505590625b927b99365a1726d429b.jpg", + "paper_title": "High-Performance Arithmetic Circuit Optimization via Differentiable Architecture Search", + "source_file": "25851_High-Performance_Arithmetic_Circuit_Optimization_via_Differentiable_Architecture_Search", + "page_idx": 5, + "section": "4.3.1 Adaptable Allocation Search via Circuit Evolution", + "bbox": [ + 179, + 74, + 823, + 289 + ], + "quality_score": 10 + }, + { + "id": "ref_0092", + "domain": "Natural Language Processing", + "diagram_type": "Methodology Figure", + "description": "Figure 1: Illustration of the zero-sum linear attention block, including the computation of deviation logits and the reweighted zero-sum softmax operation ", + "image_path": "data/spotlight_reference_images/ref_0092_26459_ZeroS_ZeroSum_Linear_Attention_for_Efficient_Transformers__47c8164ce92491496b8a2bcf9fa7ab7edc460fdfd5bd8ef3cf8bab314c81fd4a.jpg", + "paper_title": "ZeroS: Zero-Sum Linear Attention for Efficient Transformers", + "source_file": "26459_ZeroS_ZeroSum_Linear_Attention_for_Efficient_Transformers", + "page_idx": 3, + "section": "3.1 The Expansion of Softmax Function", + "bbox": [ + 196, + 90, + 802, + 256 + ], + "quality_score": 10 + }, + { + "id": "ref_0093", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: The Pipeline of CSG-PCC. Given a partial point cloud $P _ { p }$ , we divide it into patches, followed by random masking to create two incomplete point clouds, $P _ { o } ^ { ( 1 ) }$ and $P _ { o } ^ { ( 2 ) }$ . Then point clouds are processed through the encoder to extract features, and then fed into the Complete Structure Reconstruction Module. The CSRM are composed of two core components: a) Feature Disentanglement Module: maps encoder outputs into shape features $f _ { \\mathrm { s h a p e } }$ and style features $f _ { \\mathrm { s t y l e } }$ via two disentanglers. b) Prototype Projection Module: Refines $f _ { \\mathrm { s h a p e } }$ via learnable prototype memory bank $\\mathcal { M }$ , producing structure-enhanced features $\\hat { f } _ { \\mathrm { s h a p e } }$ . Then we concatenates $\\hat { f } _ { \\mathrm { s h a p e } }$ and $f _ { \\mathrm { s t y l e } }$ as decoder input to generate the completed point clouds. Dual-level contrastive learning are used to ensure structural completeness and detail preservation. ", + "image_path": "data/spotlight_reference_images/ref_0093_26655_Complete_Structure_Guided_Point_Cloud_Completion_via_Cluster-_and_Instance-Level_Contrastive_Learning__d20fe3769e61092c3c117a89910e94568e63136f5bb1bc9c2cb4c647dc5bb03d.jpg", + "paper_title": "Complete Structure Guided Point Cloud Completion via Cluster- and Instance-Level Contrastive Learning", + "source_file": "26655_Complete_Structure_Guided_Point_Cloud_Completion_via_Cluster-_and_Instance-Level_Contrastive_Learning", + "page_idx": 3, + "section": "3 Method", + "bbox": [ + 181, + 92, + 813, + 265 + ], + "quality_score": 10 + }, + { + "id": "ref_0094", + "domain": "Computer Vision", + "diagram_type": "Training Diagram", + "description": "Figure 2: Our Compressibility-inspired Unsupervised Learning via Parallel Imaging Fidelity (CUPID) method trains PD-DL models in an unsupervised and/or zero-shot manner without requiring any raw k-space data. The network is unrolled for $T$ units, with each unit consisting of regularizer (R) and data fidelity (DF). The proposed loss function comprises two terms: (a) a reweighted $\\ell _ { 1 }$ component that assesses the compressibility of the network’s output; (b) a fidelity term that ensures the output stays consistent with parallel imaging reconstructions via carefully designed perturbations, thereby preventing the network from producing a sparse all-zeros output. ", + "image_path": "data/spotlight_reference_images/ref_0094_26907_Fast_MRI_for_All_Bridging_Access_Gaps_by_Training_without_Raw_Data__b470855022bfded5864733446e130866e7eb600954465a2b6fbccb5d94396efd.jpg", + "paper_title": "Fast MRI for All: Bridging Access Gaps by Training without Raw Data", + "source_file": "26907_Fast_MRI_for_All_Bridging_Access_Gaps_by_Training_without_Raw_Data", + "page_idx": 4, + "section": "3.2 Training without raw k-space data", + "bbox": [ + 176, + 88, + 820, + 280 + ], + "quality_score": 10 + }, + { + "id": "ref_0095", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: Comparison of Model Architectures in Unified Multimodal Models. (a) AR-based models [20, 26, 21, 52–54, 18, 55] perform multimodal tasks via sequential token generation under strictly causal context modeling. (b) Hybrid AR $^ +$ Diffusion models, such as Transfusion [19] and Show-o [56], integrate AR for text and diffusion models for images, enabling improved visual generation quality. (c-d) Diffusion-based models: D-DiT [46] applies mask-based discrete diffusion to text and continuous diffusion to images, while UniDisc [48] employs mask-based discrete diffusion for both modalities. (e) FUDOKI adopts a unified discrete flow matching framework for both modalities, leveraging a metric-induced probability path to enhance performance in understanding and generation tasks. The inference advantages of FUDOKI over mask-based discrete diffusion modeling used in (c-d) are shown in Fig. 3. ", + "image_path": "data/spotlight_reference_images/ref_0095_26919_FUDOKI_Discrete_Flow-based_Unified_Understanding_and_Generation_via_Kinetic-Optimal_Velocities__9c0a452656594ea3134b9cdcb16988663e9015013c42419254bc35661139b69f.jpg", + "paper_title": "FUDOKI: Discrete Flow-based Unified Understanding and Generation via Kinetic-Optimal Velocities", + "source_file": "26919_FUDOKI_Discrete_Flow-based_Unified_Understanding_and_Generation_via_Kinetic-Optimal_Velocities", + "page_idx": 4, + "section": "3.1 Metric-induced Probability Paths with Kinetic Optimal Velocities", + "bbox": [ + 176, + 89, + 821, + 489 + ], + "quality_score": 10 + }, + { + "id": "ref_0096", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: An overview of LogicTree, which comprises three key modules: (1) Logical reasoning tree generation via iterative backward deduction based on structural pattern matching; (2) Reasoning scenario instantiation using a two-stage LLM-based approach; (3) Synthetic reasoning example post-processing. ", + "image_path": "data/spotlight_reference_images/ref_0096_26975_LogicTree_Improving_Complex_Reasoning_of_LLMs_via_Instantiated_Multi-step_Synthetic_Logical_Data__75918e90d782aa4c0011abbf0fe69a93e2595315a84e5dd3ba23b1cddfb672b5.jpg", + "paper_title": "LogicTree: Improving Complex Reasoning of LLMs via Instantiated Multi-step Synthetic Logical Data", + "source_file": "26975_LogicTree_Improving_Complex_Reasoning_of_LLMs_via_Instantiated_Multi-step_Synthetic_Logical_Data", + "page_idx": 2, + "section": "2 Preliminary", + "bbox": [ + 179, + 87, + 820, + 372 + ], + "quality_score": 10 + }, + { + "id": "ref_0097", + "domain": "Natural Language Processing", + "diagram_type": "Architecture Diagram", + "description": "Figure 1: An overview of CoAPT. Natural CLIP processes natural images and extended descriptive text inputs. Robust CLIP takes as input the images subjected to HF suppression via the real-time Adaptive-FGP algorithm and restores the corrupted natural generalization features under the guidance of Natural CLIP in the latent space. The outputs of Robust CLIP are collaboratively regulated by the frozen CLIP weights $\\theta$ , the trainable deep multimodal adversarial prompts $\\phi$ , and the low-rank residual modules $\\varphi$ . The RΓ©nyi branch explicitly regulates the discrepancy between natural and adversarial distributions by calculating the divergence between their similarity scores. ", + "image_path": "data/spotlight_reference_images/ref_0097_27132_Learning_Robust_Vision-Language_Models_from_Natural_Latent_Spaces__1c87de8566409b858e4d9bc3229961976739c1c02d52c8afc8f9c78d21a2caf3.jpg", + "paper_title": "Learning Robust Vision-Language Models from Natural Latent Spaces", + "source_file": "27132_Learning_Robust_Vision-Language_Models_from_Natural_Latent_Spaces", + "page_idx": 3, + "section": "3.1 Preliminaries", + "bbox": [ + 174, + 88, + 821, + 242 + ], + "quality_score": 10 + }, + { + "id": "ref_0098", + "domain": "Computer Vision", + "diagram_type": "Architecture Diagram", + "description": "Figure 2: DexFlyWheel Framework Overview. The framework has two stages: a warm-up stage (left) and a self-improving data flywheel stage (right). In the warm-up stage, seed demonstrations from VR teleoperation are augmented to form the initial dataset $\\mathcal { D } _ { 1 }$ . The data flywheel stage operates as a closed-loop cycle with four key components:(1) base policy $\\pi _ { \\mathrm { b a s e } }$ training to capture human-like behaviors, (2) residual policy $\\pi _ { \\mathrm { r e s } }$ training to enhance generalization, (3) combined policy Ο€combined rollouts to generate new trajectories, and (4) data augmentation to further diversify the dataset. As the flywheel iterates, both data diversity and policy capability continuously improve. ", + "image_path": "data/spotlight_reference_images/ref_0098_27155_DexFlyWheel_A_Scalable_and_Self-improving_Data_Generation_Framework_for_Dexterous_Manipulation__6cb5d9f8f05d11ff6e6bf4f69015de5ad79051d577633793092cf0b753f0d1aa.jpg", + "paper_title": "DexFlyWheel: A Scalable and Self-improving Data Generation Framework for Dexterous Manipulation", + "source_file": "27155_DexFlyWheel_A_Scalable_and_Self-improving_Data_Generation_Framework_for_Dexterous_Manipulation", + "page_idx": 3, + "section": "4 Method", + "bbox": [ + 192, + 97, + 805, + 422 + ], + "quality_score": 10 + }, + { + "id": "ref_0099", + "domain": "Machine Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 3: The overview of error space-based traceability mechanism ErrorTrace. ", + "image_path": "data/spotlight_reference_images/ref_0099_27534_ErrorTrace_A_Black-Box_Traceability_Mechanism_Based_on_Model_Family_Error_Space__3443e7f7bc9975c59b1083ffbc48907922f978304738c48dd66a04e275fa8b34.jpg", + "paper_title": "ErrorTrace: A Black-Box Traceability Mechanism Based on Model Family Error Space", + "source_file": "27534_ErrorTrace_A_Black-Box_Traceability_Mechanism_Based_on_Model_Family_Error_Space", + "page_idx": 3, + "section": "4 Methodology of ErrorTrace", + "bbox": [ + 225, + 611, + 774, + 795 + ], + "quality_score": 10 + }, + { + "id": "ref_0100", + "domain": "Machine Learning", + "diagram_type": "Architecture Diagram", + "description": "Figure 5: Overview of WEB-SHEPHERD (left) and its diverse use cases (right). ", + "image_path": "data/spotlight_reference_images/ref_0100_28009_Web-Shepherd_Advancing_PRMs_for_Reinforcing_Web_Agents__c6ed4aceca780ae65b05dd769ca4c1745cac4f7f5f1f3178b4223b9eea08d1d5.jpg", + "paper_title": "Abstract", + "source_file": "28009_Web-Shepherd_Advancing_PRMs_for_Reinforcing_Web_Agents", + "page_idx": 4, + "section": "4.3 Dataset Statistics", + "bbox": [ + 189, + 88, + 805, + 247 + ], + "quality_score": 10 + } +] \ No newline at end of file diff --git a/examples.py b/examples.py new file mode 100644 index 0000000000000000000000000000000000000000..c15081f7a916b434503d7331e1bd8bc236583624 --- /dev/null +++ b/examples.py @@ -0,0 +1,245 @@ +""" +Example usage of PaperBanana framework. + +This script demonstrates how to use PaperBanana to generate academic illustrations. +""" +import os +from paperbanana import PaperBanana, generate_illustration + +# Example methodology from a hypothetical paper +EXAMPLE_METHODOLOGY = """ +Our proposed method consists of three main stages: + +1. Feature Extraction: We use a pretrained ResNet-50 backbone to extract visual features + from input images. The features are pooled using adaptive average pooling to obtain + a fixed-size representation. + +2. Attention Mechanism: We apply multi-head self-attention to capture long-range + dependencies between different spatial regions. The attention module has 8 heads + and uses scaled dot-product attention. + +3. Classification Head: The attended features are passed through a two-layer MLP + with ReLU activation and dropout (p=0.5) for final classification. The output + layer uses softmax activation. + +The entire model is trained end-to-end using cross-entropy loss with the Adam optimizer. +""" + +EXAMPLE_CAPTION = "Architecture of our proposed attention-based image classification model" + +# Example reference set (normally would be loaded from a database) +EXAMPLE_REFERENCE_SET = [ + { + 'id': 'ref_001', + 'domain': 'Computer Vision', + 'diagram_type': 'Architecture Diagram', + 'description': 'CNN architecture with attention modules showing feature extraction, attention layers, and classification head' + }, + { + 'id': 'ref_002', + 'domain': 'Computer Vision', + 'diagram_type': 'Pipeline Diagram', + 'description': 'Image processing pipeline from input through multiple stages to output' + }, + { + 'id': 'ref_003', + 'domain': 'Natural Language Processing', + 'diagram_type': 'Architecture Diagram', + 'description': 'Transformer architecture with self-attention mechanism' + }, +] + + +def example_basic_usage(): + """Example 1: Basic usage with default settings.""" + print("\n" + "="*80) + print("EXAMPLE 1: Basic Usage") + print("="*80 + "\n") + + result = generate_illustration( + methodology_text=EXAMPLE_METHODOLOGY, + caption=EXAMPLE_CAPTION, + output_path="examples/basic_example" + ) + + print(f"\nGenerated image: {result['final_image_path']}") + print(f"Iterations: {result['iterations']}") + + +def example_with_references(): + """Example 2: Using reference examples.""" + print("\n" + "="*80) + print("EXAMPLE 2: With Reference Examples") + print("="*80 + "\n") + + result = generate_illustration( + methodology_text=EXAMPLE_METHODOLOGY, + caption=EXAMPLE_CAPTION, + reference_set=EXAMPLE_REFERENCE_SET, + output_path="examples/with_references" + ) + + print(f"\nGenerated image: {result['final_image_path']}") + + +def example_ablation_study(): + """Example 3: Ablation study - testing without certain components.""" + print("\n" + "="*80) + print("EXAMPLE 3: Ablation Study") + print("="*80 + "\n") + + # Without styling + print("\n--- Without Stylist Agent ---") + result1 = generate_illustration( + methodology_text=EXAMPLE_METHODOLOGY, + caption=EXAMPLE_CAPTION, + output_path="examples/ablation_no_style", + skip_styling=True + ) + + # Without refinement + print("\n--- Without Iterative Refinement ---") + result2 = generate_illustration( + methodology_text=EXAMPLE_METHODOLOGY, + caption=EXAMPLE_CAPTION, + output_path="examples/ablation_no_refinement", + skip_refinement=True + ) + + +def example_statistical_plot(): + """Example 4: Generating statistical plots.""" + print("\n" + "="*80) + print("EXAMPLE 4: Statistical Plot Generation") + print("="*80 + "\n") + + plot_description = """ + Create a line plot comparing accuracy across training epochs for three models: + - Baseline CNN (blue line) + - Our method without attention (orange line) + - Our full method (green line) + + X-axis: Training Epochs (0-100) + Y-axis: Validation Accuracy (%) + + The baseline should plateau around 85%, method without attention around 88%, + and full method should reach 92%. + """ + + # Example data (normally would come from actual experiments) + plot_data = { + 'epochs': list(range(0, 101, 10)), + 'baseline': [60, 70, 75, 78, 80, 82, 83, 84, 85, 85, 85], + 'no_attention': [65, 75, 80, 83, 85, 86, 87, 87.5, 88, 88, 88], + 'full_method': [70, 80, 85, 87, 89, 90, 91, 91.5, 92, 92, 92] + } + + pb = PaperBanana(mode="plot") + result = pb.generate( + methodology_text=plot_description, + caption="Comparison of validation accuracy across training epochs", + output_path="examples/accuracy_plot", + data=plot_data + ) + + print(f"\nGenerated plot code: {result['final_image_path']}") + print("Run the generated Python file to create the plot image.") + + +def example_with_neurips_references(): + """Example 5b: Using MinerU-parsed NeurIPS reference set.""" + print("\n" + "="*80) + print("EXAMPLE 5b: With NeurIPS 2025 Reference Set (from MinerU)") + print("="*80 + "\n") + + from load_reference_set import load_reference_set + + ref_set = load_reference_set() + if not ref_set: + print("No reference set found. Ensure data/spotlight_reference_set.json exists.") + return + + result = generate_illustration( + methodology_text=EXAMPLE_METHODOLOGY, + caption=EXAMPLE_CAPTION, + reference_set=ref_set, + output_path="examples/neurips_refs" + ) + print(f"\nGenerated image: {result['final_image_path']}") + + +def example_full_pipeline(): + """Example 6: Full pipeline with all features and history saving.""" + print("\n" + "="*80) + print("EXAMPLE 6: Full Pipeline with History") + print("="*80 + "\n") + + pb = PaperBanana( + reference_set=EXAMPLE_REFERENCE_SET, + mode="diagram", + max_iterations=3 + ) + + result = pb.generate( + methodology_text=EXAMPLE_METHODOLOGY, + caption=EXAMPLE_CAPTION, + output_path="examples/full_pipeline" + ) + + # Save generation history for analysis + pb.save_history("examples/generation_history.json") + + print(f"\nFinal image: {result['final_image_path']}") + print(f"Description versions: {len(result['history']['descriptions'])}") + print(f"Critiques performed: {len(result['history']['critiques'])}") + + +def main(): + """Run all examples.""" + # Create examples directory + os.makedirs("examples", exist_ok=True) + + print("\n" + "="*80) + print("PaperBanana Examples") + print("="*80) + print("\nThese examples demonstrate various features of the PaperBanana framework.") + print("Make sure you have set the GEMINI_API_KEY environment variable.\n") + + # Check for API key + if not os.environ.get("GEMINI_API_KEY"): + print("ERROR: GEMINI_API_KEY environment variable not set!") + print("Please set it with: export GEMINI_API_KEY='your-api-key'") + return + + # Run examples (comment out any you don't want to run) + try: + # Example 1: Basic usage + example_basic_usage() + + # Example 2: With references + # example_with_references() + + # Example 3: Ablation study + # example_ablation_study() + + # Example 4: Statistical plots + # example_statistical_plot() + + # Example 5b: With NeurIPS MinerU references + # example_with_neurips_references() + + # Example 6: Full pipeline + # example_full_pipeline() + + except Exception as e: + print(f"\nError during execution: {e}") + import traceback + traceback.print_exc() + + print("\n" + "="*80) + print("Examples Complete!") + print("="*80 + "\n") + + +if __name__ == "__main__": + main() diff --git a/examples/basic_example_iter1_0.jpg b/examples/basic_example_iter1_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7104ac281b6a0c9b306894aa41a8d7f357be5b0c --- /dev/null +++ b/examples/basic_example_iter1_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf68c24f6908745ff72ca23c929a5344b970ebeeba6964829af8855fba0c1882 +size 547248 diff --git a/examples/basic_example_iter2_0.jpg b/examples/basic_example_iter2_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff347aa9721645fae28bf3ed7ede2f294c1d0219 --- /dev/null +++ b/examples/basic_example_iter2_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e346eed6f32ab853005c0de3a1f8a4a33533bd26caf544647972be65ae672157 +size 623251 diff --git a/examples/basic_example_iter3_0.jpg b/examples/basic_example_iter3_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9ed2613709d718de2f3bd74c1da6bd27517cffce --- /dev/null +++ b/examples/basic_example_iter3_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25be8b5dd69315c15e9892274af3d74fc23fe6fa429f9c60e5aa3b9e8e4c5acc +size 580818 diff --git a/examples/neurips_refs_iter1_0.jpg b/examples/neurips_refs_iter1_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..37e40e45b3c462fd71f94d7cbddc52c7e41b83fa --- /dev/null +++ b/examples/neurips_refs_iter1_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b220e7c9b383ed741306cb7175f25d8a3458868bf11795e7a7dfb4051930f8af +size 588445 diff --git a/examples/neurips_refs_iter2_0.jpg b/examples/neurips_refs_iter2_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f12f7306af54d597f844927d754d6290a5c6b68 --- /dev/null +++ b/examples/neurips_refs_iter2_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57b971b3c73e81c98fc5bd309cfda2b5acdd3f51570fb2f8c67c7071ee89bc76 +size 594344 diff --git a/examples/neurips_refs_iter3_0.jpg b/examples/neurips_refs_iter3_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e01ef823e579709e92b0f96d7494f980c5f68b80 --- /dev/null +++ b/examples/neurips_refs_iter3_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7fa2c77837f69f6908993bfd0470491d7720d33c415a6835a4c2981745141bce +size 583412 diff --git a/examples/readme/ddpm_iter1_0.jpg b/examples/readme/ddpm_iter1_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4de1fe05f5408defeeb44e9d16b718d382ff56a1 --- /dev/null +++ b/examples/readme/ddpm_iter1_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:852eace212a850a9582a4db8c18005df4a609afb36aed2772d377c94532c5202 +size 626106 diff --git a/examples/readme/ddpm_iter2_0.jpg b/examples/readme/ddpm_iter2_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c38f3518bdde835bdcb5d42c3ba852ee6f31b1e6 --- /dev/null +++ b/examples/readme/ddpm_iter2_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:635ed9e024fb30ea8ee595064f382cb453772d7bc795625bd83dec8430f83ab1 +size 537829 diff --git a/examples/readme/ddpm_iter3_0.jpg b/examples/readme/ddpm_iter3_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a3c2357491fca37c77794c39ee8fa93e5601deb --- /dev/null +++ b/examples/readme/ddpm_iter3_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1261896b3eaf29d681f4ed239be9438f97d6140d50420007fb449484ea6800a +size 627689 diff --git a/examples/readme/resnet_iter1_0.jpg b/examples/readme/resnet_iter1_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ea7cfd9134661bb1ce8b9a5cdb0244e058e554d6 --- /dev/null +++ b/examples/readme/resnet_iter1_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e16f32b0a2ce57251ad456ff50c682e09ebe6ccbc92f10cf71b5a8ba124638a +size 621975 diff --git a/examples/readme/resnet_iter2_0.jpg b/examples/readme/resnet_iter2_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..71716df7299801b6b6d599ab38ec18cc2bb912a2 --- /dev/null +++ b/examples/readme/resnet_iter2_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f78f8bb786d9a2531b8b3c6880283e6e2b74ba17f37acbd46e4c5d0d554366eb +size 648849 diff --git a/examples/readme/resnet_iter3_0.jpg b/examples/readme/resnet_iter3_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..daa49b6e8fa044d2b953d4e97dd9bd9d9d812b5f --- /dev/null +++ b/examples/readme/resnet_iter3_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc874e289ff048a9d44c00c3cf204251b0938f343d5f21764be3c62d9ec4138e +size 507634 diff --git a/examples/readme/transformer_iter1_0.jpg b/examples/readme/transformer_iter1_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e67b1b983fd3f99fc3db304309d92808efbd4381 --- /dev/null +++ b/examples/readme/transformer_iter1_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:24260e649b1c68de16787adf261eeec056086ce5d1ea9b2558bafbe5d25a5562 +size 609191 diff --git a/examples/readme/transformer_iter2_0.jpg b/examples/readme/transformer_iter2_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3b81c4d2a761f7895630dea8ba1e6cf761e90b2e --- /dev/null +++ b/examples/readme/transformer_iter2_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:893fea2d68093c19e7d20de7d5b380d83aab72cf8f4527097544ef33b8d2c706 +size 506740 diff --git a/examples/readme/transformer_iter3_0.jpg b/examples/readme/transformer_iter3_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c26002b26f859c9cf67df67aca57291308068620 --- /dev/null +++ b/examples/readme/transformer_iter3_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b370e6e1683af2af988c2406fe049a78fa63819c725fd499d87206d1529c38c1 +size 485877 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..fc94c842217f59279c2e9e66ed2921f90a0ee55c --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +google-genai>=0.1.0 +pillow>=10.0.0 +numpy>=1.24.0 +matplotlib>=3.7.0 +python-dotenv>=1.0.0 +gradio==5.20.1 diff --git a/utils.py b/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..087a9cdc86d513ebcb955ac034a113320ccd153c --- /dev/null +++ b/utils.py @@ -0,0 +1,52 @@ +""" +Utility functions for PaperBanana framework. +""" +import base64 +import mimetypes +import os +from typing import Optional + + +def save_binary_file(file_name: str, data: bytes) -> str: + """ + Save binary data to a file. + + Args: + file_name: Name of the file to save + data: Binary data to write + + Returns: + Path to the saved file + """ + with open(file_name, "wb") as f: + f.write(data) + print(f"File saved to: {file_name}") + return file_name + + +def encode_image_to_base64(image_path: str) -> str: + """ + Encode an image file to base64 string. + + Args: + image_path: Path to the image file + + Returns: + Base64 encoded string + """ + with open(image_path, "rb") as f: + return base64.b64encode(f.read()).decode('utf-8') + + +def get_mime_type(file_path: str) -> Optional[str]: + """ + Get MIME type for a file. + + Args: + file_path: Path to the file + + Returns: + MIME type string or None + """ + mime_type, _ = mimetypes.guess_type(file_path) + return mime_type