Update app.py

app.py

@@ -1,175 +1,157 @@
 # app.py
+
 import streamlit as st
 import arxiv
-import requests
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
-from keybert import KeyBERT
-from pyvis.network import Network
-from pybtex.database import parse_string
-import numpy as np
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.decomposition import LatentDirichletAllocation
-import time
-import json
-
-# Initialize models
-@st.cache_resource
-def load_models():
-    # Summarization model
-    tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
-    summarizer = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")
-    
-    # Keyword model
-    kw_model = KeyBERT()
-    
-    # Research suggestion model
-    suggestion_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-base")
-    suggestion_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-base")
-    
-    return tokenizer, summarizer, kw_model, suggestion_tokenizer, suggestion_model
-
-def fetch_arxiv_papers(query, max_results=10):
-    client = arxiv.Client()
-    search = arxiv.Search(
-        query=query,
-        max_results=max_results,
-        sort_by=arxiv.SortCriterion.Relevance
-    )
-    results = []
-    for result in client.results(search):
-        results.append({
+import networkx as nx
+import matplotlib.pyplot as plt
+import datetime
+
+from transformers import pipeline
+
+# Initialize Hugging Face pipelines for summarization and text generation
+@st.cache_resource(show_spinner=False)
+def load_summarizer():
+    return pipeline("summarization", model="facebook/bart-large-cnn")
+
+@st.cache_resource(show_spinner=False)
+def load_generator():
+    return pipeline("text-generation", model="gpt2")
+
+summarizer = load_summarizer()
+generator = load_generator()
+
+# -------------------------------
+# Helper Functions
+# -------------------------------
+
+def retrieve_papers(query, max_results=5):
+    """
+    Retrieve academic papers from arXiv based on the query.
+    """
+    search = arxiv.Search(query=query, max_results=max_results)
+    papers = []
+    for result in search.results():
+        paper = {
             "title": result.title,
-            "abstract": result.summary,
-            "authors": [a.name for a in result.authors],
-            "published": result.published.strftime("%Y-%m-%d"),
-            "pdf_url": result.pdf_url,
-            "doi": result.doi
-        })
-    return results
-
-def fetch_semantic_scholar(query, max_results=5):
-    url = "https://api.semanticscholar.org/graph/v1/paper/search"
-    params = {
-        "query": query,
-        "limit": max_results,
-        "fields": "title,abstract,authors,year,references,url"
-    }
-    headers = {"x-api-key": "YOUR_API_KEY"}
-    response = requests.get(url, params=params, headers=headers)
-    if response.status_code == 200:
-        return response.json().get("data", [])
-    return []
-
-def generate_summary(text, tokenizer, model, max_length=300):
-    inputs = tokenizer([text], max_length=1024, return_tensors="pt", truncation=True)
-    summary_ids = model.generate(
-        inputs.input_ids, 
-        max_length=max_length, 
-        min_length=50, 
-        length_penalty=2.0, 
-        num_beams=4,
-        early_stopping=True
-    )
-    return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
-
-def generate_concept_map(texts, model):
-    keywords = []
-    for text in texts:
-        kws = model.extract_keywords(text, keyphrase_ngram_range=(1,2))
-        keywords.extend([kw[0] for kw in kws])
-    
-    vectorizer = TfidfVectorizer()
-    X = vectorizer.fit_transform(keywords)
-    
-    net = Network(height="400px", width="100%")
-    unique_kws = list(set(keywords))
-    
-    for kw in unique_kws:
-        net.add_node(kw, label=kw)
-    
-    similarities = (X * X.T).A
-    np.fill_diagonal(similarities, 0)
-    
-    for i in range(len(unique_kws)):
-        for j in range(i+1, len(unique_kws)):
-            if similarities[i,j] > 0.2:
-                net.add_edge(unique_kws[i], unique_kws[j], value=similarities[i,j])
-    
-    return net
-
-def generate_citations(papers):
-    citations = []
-    for paper in papers:
-        entry = {
-            "title": paper.get("title", ""),
-            "authors": paper.get("authors", []),
-            "year": paper.get("year", ""),
-            "url": paper.get("pdf_url") or paper.get("url", "")
+            "summary": result.summary,
+            "url": result.pdf_url,
+            "authors": [author.name for author in result.authors],
+            "published": result.published
         }
-        citations.append(entry)
-    return citations
-
-def generate_research_suggestions(context, tokenizer, model):
-    input_text = f"Based on this research context: {context}\nGenerate three research questions:"
-    inputs = tokenizer(input_text, return_tensors="pt")
-    outputs = model.generate(**inputs, max_length=200)
-    return tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-def main():
-    st.title("PaperPilot - Intelligent Academic Navigator")
-    
-    # Load models
-    tokenizer, summarizer, kw_model, suggestion_tokenizer, suggestion_model = load_models()
-    
-    # User input
-    query = st.text_input("Enter your research topic or question:")
-    
-    if query:
-        with st.spinner("Searching academic databases..."):
-            arxiv_results = fetch_arxiv_papers(query)
-            ss_results = fetch_semantic_scholar(query)
-            all_papers = arxiv_results + ss_results
-        
-        if not all_papers:
-            st.warning("No papers found. Try a different query.")
-            return
-            
-        # Display papers
-        st.subheader("Relevant Papers")
-        for idx, paper in enumerate(all_papers[:5]):
-            with st.expander(f"{paper['title']}"):
-                st.write(f"**Abstract:** {paper['abstract']}")
-                
-                # Generate summary
-                summary = generate_summary(paper['abstract'], tokenizer, summarizer)
-                st.write(f"**Summary:** {summary}")
-                
-                # Display metadata
-                st.write(f"**Authors:** {', '.join(paper.get('authors', []))}")
-                st.write(f"**Published:** {paper.get('published') or paper.get('year'))}")
-                st.write(f"**URL:** {paper.get('pdf_url') or paper.get('url'))}")
-        
-        # Concept Map
-        st.subheader("Research Concept Map")
-        texts = [p['abstract'] for p in all_papers]
-        net = generate_concept_map(texts, kw_model)
-        net.save_graph("concept_map.html")
-        HtmlFile = open("concept_map.html", 'r', encoding='utf-8')
-        components.html(HtmlFile.read(), height=500)
-        
-        # Citations
-        st.subheader("Citation Management")
-        citations = generate_citations(all_papers)
-        citation_format = st.selectbox("Select citation style:", ["APA", "MLA", "Chicago"])
-        
-        for cite in citations:
-            st.code(f"{cite['authors'][0]} et al. ({cite['year']}). {cite['title']}. URL: {cite['url']}")
+        papers.append(paper)
+    return papers
+
+def summarize_text(text):
+    """
+    Use a generative model to create a concise summary of the input text.
+    """
+    # The summarizer may need the text to be below a certain token length.
+    # If necessary, you could chunk the text.
+    summarized = summarizer(text, max_length=130, min_length=30, do_sample=False)
+    return summarized[0]['summary_text']
+
+def generate_concept_map(papers):
+    """
+    Generate a visual concept map by connecting papers with shared authors.
+    """
+    G = nx.Graph()
+    # Add nodes for each paper title
+    for paper in papers:
+        G.add_node(paper['title'])
+    # Create edges between papers that share at least one common author
+    for i in range(len(papers)):
+        for j in range(i + 1, len(papers)):
+            common_authors = set(papers[i]['authors']).intersection(set(papers[j]['authors']))
+            if common_authors:
+                G.add_edge(papers[i]['title'], papers[j]['title'])
+    return G
+
+def generate_citation(paper):
+    """
+    Format citation information in APA style.
+    """
+    authors = ", ".join(paper['authors'])
+    year = paper['published'].year if isinstance(paper['published'], datetime.datetime) else "n.d."
+    title = paper['title']
+    url = paper['url']
+    citation = f"{authors} ({year}). {title}. Retrieved from {url}"
+    return citation
+
+def generate_proposal_suggestions(text):
+    """
+    Generate research proposal suggestions based on the synthesized literature review.
+    """
+    prompt = (
+        "Based on the following literature review, propose a novel research proposal "
+        "including potential research questions and an outline for experimental design.\n\n"
+        f"{text}\n\nProposal:"
+    )
+    generated = generator(prompt, max_new_tokens=50, num_return_sequences=1)
+    return generated[0]['generated_text']
+
+# -------------------------------
+# Streamlit User Interface
+# -------------------------------
+
+st.title("📚PaperPilot – The Intelligent Academic Navigator")
+st.markdown("Welcome to **PaperPilot**! Enter a research topic or question below to retrieve academic papers, generate summaries, visualize concept maps, format citations, and get research proposal suggestions.")
+
+# Input section
+query = st.text_input("Research Topic or Question:")
+
+if st.button("Search"):
+
+    if query.strip() == "":
+        st.warning("Please enter a research topic or question.")
+    else:
+        # --- Step 1: Retrieve Papers ---
+        with st.spinner("Retrieving relevant academic papers..."):
+            papers = retrieve_papers(query, max_results=5)
         
-        # Research Suggestions
-        st.subheader("Research Proposal Suggestions")
-        context = " ".join([p['abstract'] for p in all_papers[:3]])
-        suggestions = generate_research_suggestions(context, suggestion_tokenizer, suggestion_model)
-        st.write(suggestions)
-
-if __name__ == "__main__":
-    main()
+        if not papers:
+            st.error("No papers found. Please try a different query.")
+        else:
+            st.success(f"Found {len(papers)} papers.")
+
+            # --- Step 2: Display Retrieved Papers ---
+            st.header("Retrieved Papers")
+            for idx, paper in enumerate(papers, start=1):
+                with st.expander(f"{idx}. {paper['title']}"):
+                    st.markdown(f"**Authors:** {', '.join(paper['authors'])}")
+                    st.markdown(f"**Published:** {paper['published'].strftime('%Y-%m-%d') if isinstance(paper['published'], datetime.datetime) else 'n.d.'}")
+                    st.markdown(f"**Link:** [PDF Link]({paper['url']})")
+                    st.markdown("**Abstract:**")
+                    st.write(paper['summary'])
+
+            # --- Step 3: Generate Summaries & Literature Review ---
+            st.header("Automated Summaries & Literature Review")
+            combined_summary = ""
+            for paper in papers:
+                st.subheader(f"Summary for: {paper['title']}")
+                # Use the paper summary as input for further summarization
+                summary_text = summarize_text(paper['summary'])
+                st.write(summary_text)
+                combined_summary += summary_text + " "
+
+            # --- Step 4: Create Visual Concept Map & Gap Analysis ---
+            st.header("Visual Concept Map & Gap Analysis")
+            G = generate_concept_map(papers)
+            if len(G.nodes) > 0:
+                fig, ax = plt.subplots(figsize=(8, 6))
+                pos = nx.spring_layout(G, seed=42)
+                nx.draw_networkx(G, pos, with_labels=True, node_color='skyblue', edge_color='gray', node_size=1500, font_size=8, ax=ax)
+                st.pyplot(fig)
+            else:
+                st.info("Not enough data to generate a concept map.")
+
+            # --- Step 5: Citation & Reference Management ---
+            st.header("Formatted Citations (APA Style)")
+            for paper in papers:
+                citation = generate_citation(paper)
+                st.markdown(f"- {citation}")
+
+            # --- Step 6: Research Proposal Assistance ---
+            st.header("Research Proposal Suggestions")
+            proposal = generate_proposal_suggestions(combined_summary)
+            st.write(proposal)
+st.caption("Built with ❤️")