Create app.py

app.py

@@ -0,0 +1,250 @@
+import streamlit as st
+import pandas as pd
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from peft import PeftModel
+from text_processing import TextProcessor
+import gc
+import time
+from pathlib import Path
+
+# Configure page
+st.set_page_config(
+    page_title="Biomedical Papers Analysis",
+    page_icon="🔬",
+    layout="wide"
+)
+
+# Initialize session state
+if 'processed_data' not in st.session_state:
+    st.session_state.processed_data = None
+if 'summaries' not in st.session_state:
+    st.session_state.summaries = None
+if 'text_processor' not in st.session_state:
+    st.session_state.text_processor = None
+
+def load_model(model_type):
+    """Load appropriate model based on type"""
+    if model_type == "summarize":
+        base_model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")
+        model = PeftModel.from_pretrained(base_model, "pendar02/results")
+        tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
+    else:  # question_focused
+        base_model = AutoModelForSeq2SeqLM.from_pretrained("GanjinZero/biobart-base")
+        model = PeftModel.from_pretrained(base_model, "pendar02/biobart-finetune")
+        tokenizer = AutoTokenizer.from_pretrained("GanjinZero/biobart-base")
+    
+    return model, tokenizer
+
+@st.cache_data
+def process_excel(uploaded_file):
+    """Process uploaded Excel file"""
+    try:
+        df = pd.read_excel(uploaded_file)
+        required_columns = ['Abstract', 'Article Title', 'Authors', 
+                          'Source Title', 'Publication Year', 'DOI']
+        
+        # Check required columns
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        if missing_columns:
+            st.error(f"Missing required columns: {', '.join(missing_columns)}")
+            return None
+            
+        return df[required_columns]
+    except Exception as e:
+        st.error(f"Error processing file: {str(e)}")
+        return None
+
+def generate_summary(text, model, tokenizer):
+    """Generate summary for single abstract"""
+    inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)
+    
+    with torch.no_grad():
+        summary_ids = model.generate(
+            **{
+                "input_ids": inputs["input_ids"],
+                "attention_mask": inputs["attention_mask"],
+                "max_length": 150,
+                "min_length": 50,
+                "num_beams": 4,
+                "length_penalty": 2.0,
+                "early_stopping": True
+            }
+        )
+    
+    return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+
+def generate_focused_summary(question, abstracts, model, tokenizer):
+    """Generate focused summary based on question"""
+    combined_input = f"Question: {question} Abstracts: " + " [SEP] ".join(abstracts)
+    
+    inputs = tokenizer(combined_input, return_tensors="pt", max_length=1024, truncation=True)
+    
+    with torch.no_grad():
+        summary_ids = model.generate(
+            **{
+                "input_ids": inputs["input_ids"],
+                "attention_mask": inputs["attention_mask"],
+                "max_length": 200,
+                "min_length": 50,
+                "num_beams": 4,
+                "length_penalty": 2.0,
+                "early_stopping": True
+            }
+        )
+    
+    return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+
+def main():
+    st.title("🔬 Biomedical Papers Analysis")
+    
+    # Sidebar
+    st.sidebar.header("About")
+    st.sidebar.info(
+        "This app analyzes biomedical research papers. Upload an Excel file "
+        "containing paper details and abstracts to:"
+        "\n- Generate individual summaries"
+        "\n- Get question-focused insights"
+    )
+    
+    # Initialize text processor if not already done
+    if st.session_state.text_processor is None:
+        with st.spinner("Loading NLP models..."):
+            st.session_state.text_processor = TextProcessor()
+    
+    # File upload section
+    uploaded_file = st.file_uploader(
+        "Upload Excel file containing papers", 
+        type=['xlsx', 'xls'],
+        help="File must contain: Abstract, Article Title, Authors, Source Title, Publication Year, DOI"
+    )
+    
+    if uploaded_file is not None:
+        # Process Excel file
+        if st.session_state.processed_data is None:
+            with st.spinner("Processing file..."):
+                df = process_excel(uploaded_file)
+                if df is not None:
+                    st.session_state.processed_data = df
+        
+        if st.session_state.processed_data is not None:
+            df = st.session_state.processed_data
+            st.write(f"📊 Loaded {len(df)} papers")
+            
+            # Individual Summaries Section
+            st.header("📝 Individual Paper Summaries")
+            
+            if st.session_state.summaries is None and st.button("Generate Individual Summaries"):
+                try:
+                    with st.spinner("Generating summaries..."):
+                        # Load summarization model
+                        model, tokenizer = load_model("summarize")
+                        
+                        # Process abstracts
+                        progress_bar = st.progress(0)
+                        summaries = []
+                        
+                        for i, abstract in enumerate(df['Abstract']):
+                            summary = generate_summary(abstract, model, tokenizer)
+                            summaries.append(summary)
+                            progress_bar.progress((i + 1) / len(df))
+                        
+                        st.session_state.summaries = summaries
+                        
+                        # Clear GPU memory
+                        del model
+                        del tokenizer
+                        torch.cuda.empty_cache()
+                        gc.collect()
+                
+                except Exception as e:
+                    st.error(f"Error generating summaries: {str(e)}")
+            
+            if st.session_state.summaries is not None:
+                # Display summaries with sorting options
+                col1, col2 = st.columns(2)
+                with col1:
+                    sort_column = st.selectbox("Sort by:", df.columns)
+                with col2:
+                    ascending = st.checkbox("Ascending order", True)
+                
+                # Create display dataframe
+                display_df = df.copy()
+                display_df['Summary'] = st.session_state.summaries
+                sorted_df = display_df.sort_values(by=sort_column, ascending=ascending)
+                
+                # Show interactive table
+                st.dataframe(
+                    sorted_df,
+                    column_config={
+                        "Abstract": st.column_config.TextColumn(
+                            "Abstract",
+                            width="medium",
+                            help="Original abstract text"
+                        ),
+                        "Summary": st.column_config.TextColumn(
+                            "Summary",
+                            width="medium",
+                            help="Generated summary"
+                        )
+                    },
+                    hide_index=True
+                )
+            
+            # Question-focused Summary Section
+            st.header("❓ Question-focused Summary")
+            question = st.text_input("Enter your research question:")
+            
+            if question and st.button("Generate Focused Summary"):
+                try:
+                    with st.spinner("Analyzing relevant papers..."):
+                        # Find relevant abstracts
+                        results = st.session_state.text_processor.find_most_relevant_abstracts(
+                            question,
+                            df['Abstract'].tolist(),
+                            top_k=5
+                        )
+                        
+                        # Show spell-check suggestion if needed
+                        if results['processed_question']['original'] != results['processed_question']['corrected']:
+                            st.info(f"Did you mean: {results['processed_question']['corrected']}?")
+                        
+                        # Load question-focused model
+                        model, tokenizer = load_model("question_focused")
+                        
+                        # Get relevant abstracts and generate summary
+                        relevant_abstracts = df['Abstract'].iloc[results['top_indices']].tolist()
+                        focused_summary = generate_focused_summary(
+                            results['processed_question']['corrected'],
+                            relevant_abstracts,
+                            model,
+                            tokenizer
+                        )
+                        
+                        # Display results
+                        st.subheader("Summary")
+                        st.write(focused_summary)
+                        
+                        # Show relevant papers
+                        st.subheader("Most Relevant Papers")
+                        relevant_papers = df.iloc[results['top_indices']][
+                            ['Article Title', 'Authors', 'Publication Year', 'DOI']
+                        ]
+                        relevant_papers['Relevance Score'] = results['scores']
+                        st.dataframe(relevant_papers, hide_index=True)
+                        
+                        # Show identified medical terms
+                        st.subheader("Identified Medical Terms")
+                        st.write(", ".join(results['processed_question']['medical_entities']))
+                        
+                        # Clear GPU memory
+                        del model
+                        del tokenizer
+                        torch.cuda.empty_cache()
+                        gc.collect()
+                
+                except Exception as e:
+                    st.error(f"Error generating focused summary: {str(e)}")
+
+if __name__ == "__main__":
+    main()