Spaces:
Running
Running
| 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""" | |
| try: | |
| if model_type == "summarize": | |
| base_model = AutoModelForSeq2SeqLM.from_pretrained( | |
| "facebook/bart-large-cnn", | |
| cache_dir="./models" | |
| ) | |
| model = PeftModel.from_pretrained( | |
| base_model, | |
| "pendar02/results", | |
| load_in_8bit=False, | |
| device_map="auto", | |
| torch_dtype=torch.float32 | |
| ) | |
| tokenizer = AutoTokenizer.from_pretrained( | |
| "facebook/bart-large-cnn", | |
| cache_dir="./models" | |
| ) | |
| else: # question_focused | |
| base_model = AutoModelForSeq2SeqLM.from_pretrained( | |
| "GanjinZero/biobart-base", | |
| cache_dir="./models" | |
| ) | |
| model = PeftModel.from_pretrained( | |
| base_model, | |
| "pendar02/biobart-finetune", | |
| load_in_8bit=False, | |
| device_map="auto", | |
| torch_dtype=torch.float32 | |
| ) | |
| tokenizer = AutoTokenizer.from_pretrained( | |
| "GanjinZero/biobart-base", | |
| cache_dir="./models" | |
| ) | |
| model.eval() | |
| return model, tokenizer | |
| except Exception as e: | |
| st.error(f"Error loading model: {str(e)}") | |
| raise | |
| 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""" | |
| if not isinstance(text, str) or not text.strip(): | |
| return "No abstract available to summarize." | |
| 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.dropna(subset=["Abstract"]) | |
| if st.session_state.processed_data is not None: | |
| df = st.session_state.processed_data | |
| st.write(f"📊 Loaded {len(df)} papers with abstracts") | |
| # 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, 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 | |
| ) | |
| # 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( | |
| question, | |
| 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) | |
| # 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() | |