Upload 3 files

app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 import spaces
-from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer, pipeline
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
 import torch
 from threading import Thread
 
@@ -13,12 +13,11 @@ from marker.settings import settings
 from marker.logger import configure_logging
 from surya.settings import settings as surya_settings
 import traceback
-import re
 
 
 # marker
 configure_logging()
-MAX_PAGES = 30
+MAX_PAGES = 20
 MIN_LENGTH=200
 settings.EXTRACT_IMAGES = False
 settings.DEBUG = False
@@ -38,130 +37,12 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map="auto"
 )
 tokenizer = AutoTokenizer.from_pretrained(model_name)
-# Set pad_token to eos_token if not set (common for Llama models)
-if tokenizer.pad_token is None:
-    tokenizer.pad_token = tokenizer.eos_token
-    tokenizer.pad_token_id = tokenizer.eos_token_id
 streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, decode_kwargs=dict(skip_special_tokens=True))
 
-# Initialize AI classifier for paper detection
-# Using a lightweight model for text classification
-try:
-    paper_classifier = pipeline(
-        "text-classification",
-        model="fabriceyhc/bert-base-uncased-arxiv-classification",  # You can use other models
-        device=0 if torch.cuda.is_available() else -1,
-        truncation=True,
-        max_length=512
-    )
-    AI_CLASSIFIER_AVAILABLE = True
-except Exception as e:
-    print(f"Warning: Could not load AI classifier: {e}")
-    print("Falling back to rule-based detection only")
-    paper_classifier = None
-    AI_CLASSIFIER_AVAILABLE = False
-
-# Alternative: Use zero-shot classification (more flexible but slower)
-def init_zero_shot_classifier():
-    try:
-        from transformers import pipeline
-        classifier = pipeline(
-            "zero-shot-classification",
-            model="facebook/bart-large-mnli",
-            device=0 if torch.cuda.is_available() else -1
-        )
-        return classifier
-    except Exception as e:
-        print(f"Could not initialize zero-shot classifier: {e}")
-        return None
-
-# If primary classifier fails, try zero-shot
-if not AI_CLASSIFIER_AVAILABLE:
-    zero_shot_classifier = init_zero_shot_classifier()
-    if zero_shot_classifier:
-        AI_CLASSIFIER_AVAILABLE = True
-else:
-    zero_shot_classifier = None
-
-def ai_check_paper(text):
-    """
-    Use AI model to check if text is a research paper
-    Returns (is_paper, confidence, ai_reason)
-    """
-    if not AI_CLASSIFIER_AVAILABLE:
-        return None, 0, "AI classifier not available"
-    
-    # Truncate text for AI model (keep beginning and end which are most informative)
-    max_chars = 2000
-    if len(text) > max_chars * 2:
-        text_sample = text[:max_chars] + "\n...\n" + text[-max_chars:]
-    else:
-        text_sample = text[:max_chars*2]
-    
-    try:
-        if zero_shot_classifier and not paper_classifier:
-            # Use zero-shot classification
-            labels = [
-                "academic research paper",
-                "scientific article", 
-                "technical report",
-                "business document",
-                "news article",
-                "blog post",
-                "other document"
-            ]
-            
-            result = zero_shot_classifier(
-                text_sample,
-                candidate_labels=labels,
-                hypothesis_template="This text is a {}."
-            )
-            
-            # Check if top labels are paper-related
-            top_label = result['labels'][0]
-            top_score = result['scores'][0]
-            
-            paper_labels = {"academic research paper", "scientific article", "technical report"}
-            
-            if top_label in paper_labels:
-                if top_score > 0.7:
-                    return True, top_score, f"AI detected: {top_label} (confidence: {top_score:.2f})"
-                elif top_score > 0.5:
-                    return True, 0.6, f"AI detected: likely {top_label} (confidence: {top_score:.2f})"
-                else:
-                    return False, top_score, f"AI detected: uncertain document type"
-            else:
-                return False, 1-top_score, f"AI detected: {top_label}, not a research paper"
-                
-        elif paper_classifier:
-            # Use pre-trained classifier
-            result = paper_classifier(text_sample)[0]
-            
-            # Check if the label indicates it's a paper
-            # This depends on the specific model used
-            label = result['label'].lower()
-            score = result['score']
-            
-            # Adjust based on your chosen model's labels
-            paper_keywords = ['cs', 'math', 'physics', 'eess', 'econ', 'stat', 'q-bio']
-            is_paper = any(keyword in label for keyword in paper_keywords)
-            
-            if is_paper:
-                return True, score, f"AI detected: {label} paper (confidence: {score:.2f})"
-            else:
-                return False, 1-score, f"AI detected: not a research paper"
-                
-    except Exception as e:
-        print(f"AI classification error: {e}")
-        return None, 0, "AI classification failed"
-    
-    return None, 0, "AI check not performed"
-
 # Define prompts
 SYSTEM_PROMPT_TEMPLATE = """You are an expert reviewer for AI conferences. You follow best practices and review papers according to the reviewer guidelines.
-
 Reviewer guidelines:
-1. Read the paper: It's important to carefully read through the entire paper, and to look up any related work and citations that will help you comprehensively evaluate it. Be sure to give yourself sufficient time for this step.
+1. Read the paper: It’s important to carefully read through the entire paper, and to look up any related work and citations that will help you comprehensively evaluate it. Be sure to give yourself sufficient time for this step.
 2. While reading, consider the following:
     - Objective of the work: What is the goal of the paper? Is it to better address a known application or problem, draw attention to a new application or problem, or to introduce and/or explain a new theoretical finding? A combination of these? Different objectives will require different considerations as to potential value and impact.
     - Strong points: is the submission clear, technically correct, experimentally rigorous, reproducible, does it present novel findings (e.g. theoretically, algorithmically, etc.)?
@@ -179,18 +60,13 @@ Reviewer guidelines:
     - Provide supporting arguments for your recommendation.
     - Ask questions you would like answered by the authors to help you clarify your understanding of the paper and provide the additional evidence you need to be confident in your assessment.
     - Provide additional feedback with the aim to improve the paper. Make it clear that these points are here to help, and not necessarily part of your decision assessment.
-
 Your write reviews in markdown format. Your reviews contain the following sections:
-
 # Review
-
 {review_fields}
-
 Your response must only contain the review in markdown format with sections as defined above.
 """
 
 USER_PROMPT_TEMPLATE = """Review the following paper:
-
 {paper_text}
 """
 
@@ -309,126 +185,7 @@ This should be a holistic assessment, not a repetition of individual sections.
 
 """
 
-# Enhanced function that combines rule-based and AI checks
-def is_research_paper(text, use_ai=True):
-    """
-    Check if the given text appears to be a research paper.
-    Combines rule-based detection with AI classification.
-    Returns (is_paper, confidence, reason)
-    """
-    if not text or len(text) < MIN_LENGTH:
-        return False, 0, "Text is too short to be a research paper"
-    
-    text_lower = text.lower()
-    
-    # Academic paper indicators (must have multiple)
-    indicators = {
-        'abstract': bool(re.search(r'\babstract\b', text_lower)),
-        'introduction': bool(re.search(r'\bintroduction\b', text_lower)),
-        'conclusion': bool(re.search(r'\bconclusion\b', text_lower)),
-        'references': bool(re.search(r'\b(references|bibliography)\b', text_lower)),
-        'methodology': bool(re.search(r'\b(method|methodology|approach|algorithm|model)\b', text_lower)),
-        'results': bool(re.search(r'\b(results|experiments|evaluation|analysis)\b', text_lower)),
-        'citations': bool(re.search(r'\[[\d,\s]+\]|\(\w+,?\s*\d{4}\)', text)),  # [1,2,3] or (Author, 2024)
-        'figures_tables': bool(re.search(r'\b(figure\s*\d+|table\s*\d+|fig\.\s*\d+)\b', text_lower)),
-        'academic_terms': bool(re.search(r'\b(propose|present|demonstrate|evaluate|contribution|novel|state-of-the-art)\b', text_lower))
-    }
-    
-    # Count how many indicators are present
-    indicator_count = sum(indicators.values())
-    
-    # Check for non-paper content with context
-    # Only flag as non-paper if these terms appear WITHOUT academic context
-    non_paper_indicators = []
-    
-    # Check for invoice/receipt patterns (multiple commercial terms together)
-    if re.search(r'\b(invoice|receipt)\b', text_lower) and re.search(r'\b(total|amount|payment|billing)\b', text_lower):
-        non_paper_indicators.append(True)
-    
-    # Check for purchase order specifically (not just "purchase")
-    if re.search(r'\bpurchase order\b', text_lower):
-        non_paper_indicators.append(True)
-    
-    # Check for letter format
-    if re.search(r'\b(dear\s+(sir|madam|customer)|sincerely|best regards|yours truly)\b', text_lower):
-        non_paper_indicators.append(True)
-    
-    # Check for textbook structure
-    if re.search(r'\b(chapter\s+\d+|lesson\s+\d+|exercise\s+\d+)\b', text_lower) and indicator_count < 3:
-        non_paper_indicators.append(True)
-    
-    # Check for HTML/web content
-    if re.search(r'<html|<body|<div|<script|<!DOCTYPE', text_lower):
-        non_paper_indicators.append(True)
-    
-    # Check for recipe/cooking content
-    if re.search(r'\b(ingredients|recipe|preparation|cooking time|servings)\b', text_lower) and not re.search(r'\b(algorithm|method|experiment)\b', text_lower):
-        non_paper_indicators.append(True)
-    
-    # If we have strong non-paper indicators AND weak academic indicators, it's not a paper
-    if any(non_paper_indicators) and indicator_count < 6:
-        return False, 0, "Content appears to be a non-academic document"
-    
-    # Get AI assessment if available and requested
-    ai_result = None
-    ai_confidence = 0
-    ai_reason = ""
-    
-    if use_ai and AI_CLASSIFIER_AVAILABLE:
-        ai_result, ai_confidence, ai_reason = ai_check_paper(text)
-    
-    # Combine rule-based and AI assessments
-    # Rule-based decision logic
-    if indicator_count == 9:
-        rule_decision = True
-        rule_confidence = 0.9
-        rule_reason = f"Found all {indicator_count}/9 academic paper indicators"
-    elif indicator_count >= 6:
-        rule_decision = True
-        rule_confidence = 0.6
-        missing = [k for k, v in indicators.items() if not v]
-        rule_reason = f"Found only {indicator_count}/9 indicators. Missing: {', '.join(missing)}"
-    else:
-        rule_decision = False
-        rule_confidence = 0
-        missing = [k for k, v in indicators.items() if not v]
-        rule_reason = f"Found only {indicator_count}/9 indicators. Missing: {', '.join(missing[:4])}"
-    
-    # Combine decisions
-    if ai_result is not None:
-        # Both methods available - combine them
-        # Weight: 60% rule-based, 40% AI
-        combined_confidence = (rule_confidence * 0.6) + (ai_confidence * 0.4)
-        
-        # Decision logic
-        if rule_decision and ai_result:
-            # Both agree it's a paper
-            if combined_confidence >= 0.9:
-                return True, 0.9, f"High confidence: {rule_reason}. {ai_reason}"
-            else:
-                return True, 0.6, f"Warning: {rule_reason}. {ai_reason}"
-        elif not rule_decision and not ai_result:
-            # Both agree it's not a paper
-            return False, 0, f"Not a research paper. {rule_reason}. {ai_reason}"
-        else:
-            # Disagreement - use weighted decision
-            if combined_confidence >= 0.5:
-                return True, 0.6, f"Mixed signals: {rule_reason}. {ai_reason}"
-            else:
-                return False, 0, f"Likely not a research paper. {rule_reason}. {ai_reason}"
-    else:
-        # Only rule-based available
-        if rule_decision:
-            if rule_confidence >= 0.9:
-                return True, 0.9, f"High confidence: {rule_reason}"
-            else:
-                return True, 0.6, f"Warning: {rule_reason}"
-        else:
-            return False, 0, f"Does not appear to be a research paper. {rule_reason}"
-
-# Rest of the code remains exactly the same...
-# (create_messages, convert_file, process_file, generate functions remain unchanged)
-
+# functions
 def create_messages(review_fields, paper_text):
     messages = [
         {"role": "system", "content": SYSTEM_PROMPT_TEMPLATE.format(review_fields=review_fields)},
@@ -461,51 +218,28 @@ def process_file(file):
             raise ValueError()
     except spaces.zero.gradio.HTMLError as e:
         print(e)
-        return "Error. GPU quota exceeded. Please return later.", False
+        return "Error. GPU quota exceeded. Please return later."
+    # except gradio.exceptions.Error as e:
+    #     if 'GPU task aborted' in str(e):
+    #         print(e)
+    #         return 'GPU task aborted'
     except Exception as e:
         print(traceback.format_exc())
         print(f"Error converting {filepath}: {e}")
-        return "Error processing pdf", False
-    
-    # Check if it's a research paper (with AI)
-    is_paper, confidence, reason = is_research_paper(paper_text, use_ai=True)
-    if not is_paper:
-        return f"⚠️ **Not a Research Paper**\n\nThe uploaded document does not appear to be a research paper.\n\nReason: {reason}\n\nPlease upload a proper academic/research paper with sections like Abstract, Introduction, Methodology, Results, and References.", False
-    
-    # If confidence is low (6-8 indicators), add a warning
-    if confidence < 0.9:
-        paper_text = f"⚠️ **Warning**: {reason}. \n\nThe document may be incomplete or missing key sections. Proceeding with review generation...\n\n---\n\n{paper_text}"
-    
-    return paper_text, True
-
-@spaces.GPU(duration=190)
+        return "Error processing pdf"
+    return paper_text
+
+
+@spaces.GPU(duration=90)
 def generate(paper_text, review_template):
-    # Final check before generation
-    is_paper, confidence, reason = is_research_paper(paper_text, use_ai=False)  # Quick check without AI
-    if not is_paper:
-        return f"⚠️ Cannot generate review: {reason}"
-    
     messages = create_messages(review_template, paper_text)
     input_ids = tokenizer.apply_chat_template(
         messages,
         add_generation_prompt=True,
         return_tensors='pt'
     ).to(model.device)
-    
-    # Create attention mask
-    attention_mask = torch.ones_like(input_ids)
-    
     print(f"input_ids shape: {input_ids.shape}")
-    generation_kwargs = dict(
-        input_ids=input_ids,
-        attention_mask=attention_mask,
-        streamer=streamer,
-        max_new_tokens=4096,
-        do_sample=True,
-        temperature=0.6,
-        top_p=0.9,
-        pad_token_id=tokenizer.pad_token_id
-    )
+    generation_kwargs = dict(input_ids=input_ids, streamer=streamer, max_new_tokens=4096, do_sample=True, temperature=0.6, top_p=0.9)
     thread = Thread(target=model.generate, kwargs=generation_kwargs)
     thread.start()
     generated_text = ""
@@ -513,97 +247,50 @@ def generate(paper_text, review_template):
         generated_text += new_text
         yield generated_text.replace("<|eot_id|>", "")
 
-# UI code remains exactly the same...
+
+
 # ui
+#8C1B13 red
+#4D8093 blue
+#767676 med grey
+#EFECE3 light grey
+#DDDDDD silver below red
+#FFFDFA white
+
 title = """<h1 align="center">OpenReviewer</h1>
 <div align="center">Using <a href="https://huggingface.co/maxidl/Llama-OpenReviewer-8B" target="_blank"><code>Llama-OpenReviewer-8B</code></a> - Built with Llama</div>
 """
 
 description = """This is an online demo featuring [Llama-OpenReviewer-8B](https://huggingface.co/maxidl/Llama-OpenReviewer-8B), a large language model that generates high-quality reviews for machine learning and AI papers.
-
 ## Demo Guidelines
-
-1. Upload your paper as a PDF file. Alternatively you can paste the full text of your paper in markdown format below. We do **not** store your data. User data is kept in ephemeral storage during processing.
-
-2. Once you upload a PDF, it will be converted to markdown and **validated to ensure it's a research paper**. This takes some time as it runs multiple transformer models to parse the layout and extract text and tables. Check out [marker](https://github.com/VikParuchuri/marker/tree/master) for details.
-
-3. Having obtained a markdown version of your paper and confirmed it's a valid research paper, you can now click *Generate Review*.
-
+1. Upload you paper as a pdf file. Alternatively you can paste the full text of your paper in markdown format below. We do **not** store your data. User data is kept in ephemeral storage during processing.
+2. Once you upload a pdf it will be converted to markdown. This takes some time as it runs multiple transformer models to parse the layout and extract text and tables. Checkout [marker](https://github.com/VikParuchuri/marker/tree/master) for details.
+3. Having obtained a markdown version of your paper, you can now click *Generate Review*.
 Take a look at the Review Template to properly interpret the generated review. You can also change the review template before generating in case you want to generate a review with a different schema and aspects.
-
 To obtain more than one review, just generate again.
-
 **GPU quota:** If exceeded, either sign in with your HF account or come back later. Your quota has a half-life of 2 hours.
-
 """
 
 theme = gr.themes.Default(primary_hue="gray", secondary_hue="blue", neutral_hue="slate")
 with gr.Blocks(theme=theme) as demo:
     title = gr.HTML(title)
     description = gr.Markdown(description)
-    
-    # Add paper validation status
-    with gr.Row():
-        file_input = gr.File(file_types=[".pdf"], file_count="single")
-        validation_status = gr.Markdown("", visible=False)
-    
-    paper_text_field = gr.Textbox("Upload a pdf or paste the full text of your paper in markdown format here.", label="Paper Text", lines=20, max_lines=20, autoscroll=False)
-    
+    file_input = gr.File(file_types=[".pdf"], file_count="single")
+    paper_text_field= gr.Textbox("Upload a pdf or paste the full text of your paper in markdown format here.", label="Paper Text", lines=20, max_lines=20, autoscroll=False)
     with gr.Accordion("Review Template", open=False):
         review_template_description = gr.Markdown("We use the ICLR 2025 review template by default, but you can modify the template below as you like.")
         review_template_field = gr.Textbox(label=" ",lines=20, max_lines=20, autoscroll=False, value=REVIEW_FIELDS)
-    
-    generate_button = gr.Button("Generate Review", interactive=False)
-    
-    def handle_file_upload(file):
-        if file is None:
-            return "", gr.update(visible=False), gr.update(interactive=False)
-        text, is_valid = process_file(file)
-        if is_valid:
-            # Check confidence level for appropriate message
-            is_paper, confidence, reason = is_research_paper(text, use_ai=False)  # Quick check for display
-            if confidence >= 0.9:
-                status_msg = "✅ **Document validated**: This appears to be a complete research paper."
-            else:
-                status_msg = f"⚠️ **Warning**: {reason}\n\nThe document may be incomplete or missing key sections of a research paper."
-            return text, gr.update(value=status_msg, visible=True), gr.update(interactive=True)
-        else:
-            return text, gr.update(value="❌ **Validation failed**: Please upload a research paper.", visible=True), gr.update(interactive=False)
-    
-    def handle_text_change(text):
-        if not text or len(text) < 200:
-            return gr.update(interactive=False), gr.update(visible=False)
-        
-        is_paper, confidence, reason = is_research_paper(text, use_ai=True)
-        if is_paper:
-            if confidence >= 0.9:
-                status = "✅ **Text validated**: This appears to be a complete research paper."
-            else:
-                # confidence < 0.9 means warning (6-8 indicators)
-                status = f"⚠️ **Warning**: {reason}\n\nThe document may be incomplete or missing key sections."
-            return gr.update(interactive=True), gr.update(value=status, visible=True)
-        else:
-            return gr.update(interactive=False), gr.update(value=f"❌ **Not a research paper**: {reason}", visible=True)
-    
-    file_input.upload(handle_file_upload, file_input, [paper_text_field, validation_status, generate_button])
-    paper_text_field.change(handle_text_change, paper_text_field, [generate_button, validation_status])
-    
+    generate_button = gr.Button("Generate Review", interactive=not paper_text_field)
+    file_input.upload(process_file, file_input, paper_text_field)
+    paper_text_field.change(lambda text: gr.update(interactive=True) if len(text) > 200 else gr.update(interactive=False), paper_text_field, generate_button)
+
     review_field = gr.Markdown("\n\n\n\n\n", label="Review")
-    generate_button.click(
-        fn=lambda: gr.update(interactive=False), 
-        inputs=None, 
-        outputs=generate_button
-    ).then(
-        generate, 
-        [paper_text_field, review_template_field], 
-        review_field
-    ).then(
-        fn=lambda: gr.update(interactive=True), 
-        inputs=None, 
-        outputs=generate_button
-    )
-    
+    generate_button.click(fn=lambda: gr.update(interactive=False), inputs=None, outputs=generate_button).then(generate, [paper_text_field, review_template_field], review_field).then(fn=lambda: gr.update(interactive=True), inputs=None, outputs=generate_button)
+
     demo.title = "OpenReviewer"
 
+
+
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

requirements.txt

@@ -1,4 +1,3 @@
-gradio==5.8.0
 transformers==4.45.2
 accelerate
 marker-pdf @ git+https://github.com/maxidl/marker-arena.git@ffeb6ee6c1092f1e008000cb8d1d6240a7baeb52