Rebuild commit without large PDF

.gitattributes

@@ -33,3 +33,7 @@ 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
+knowledge/kcc-sleeptextbook-print.pdf filter=lfs diff=lfs merge=lfs -text
+faiss_index/index.faiss filter=lfs diff=lfs merge=lfs -text
+faiss_index/index.pkl filter=lfs diff=lfs merge=lfs -text
+knowledge/eeg_sig_proc.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,83 @@
+# 🧠 NeuroNap
+
+**NeuroNap** is an EEG-based sleep analysis tool that processes EEG CSV files to analyze sleep stages, generate hypnograms, visualize frequency spectra, and provide LLM-driven insights using **Gemini**.  
+Built with **Python** and **Gradio**, it uses **YASA** for sleep stage classification and **HMM** for clustering and offers an interactive interface for researchers and clinicians studying sleep patterns.
+
 ---
-title: NeuroNap
-emoji: 🐠
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: 'NeuroNap: EEG-based sleep analysis tool'
+
+## 🚀 Features
+
+- **EEG Processing:**  
+  Processes raw EEG CSV files using **bandpass** and **notch filters** to remove noise and artifacts, ensuring clean, reliable signal data.
+
+- **Sleep Stage Classification:**  
+  Utilizes **YASA** (Yet Another Sleep Analysis) to automatically classify sleep stages — **W, N1, N2, N3, and REM** — and compute essential sleep metrics such as **Total Sleep Time (TST)**, **Sleep Efficiency (SE)**, and **Wake After Sleep Onset (WASO)**.
+
+- **Clustering:**  
+  Applies **Hidden Markov Models (HMM)** to cluster EEG-derived features, revealing latent patterns and transitions across sleep stages.
+
+- **Visualizations:**  
+  Generates detailed plots for **EEG signals**, **hypnograms**, **frequency spectra**, and **band-specific waveforms**, allowing for intuitive data interpretation.
+
+- **Sleep Statistics:**  
+  Displays comprehensive sleep metrics (e.g., **Total Sleep Time**, **Sleep Efficiency**) with expandable tables showing additional parameters like **Time in Bed (TIB)**, **Sleep Period Time (SPT)**, and **latencies**.
+
+- **LLM Insights:**  
+  Integrates **Gemini** via **LangChain** for natural language interaction, using a **FAISS vector store** for context-aware sleep data insights.
+
+- **Exportable Outputs:**  
+  Enables easy download of results in **CSV** format (clean EEG, extracted features, clusters) and **PDF** format (visual reports and plots).
+ 
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## ⚙️ Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/NeuroNap.git
+cd NeuroNap
+
+# Create a virtual environment
+python -m venv venv
+
+# Activate the environment
+source venv/bin/activate   # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+🔑 **API Setup**  
+Set your Gemini API key in a `.env` file:  
+```bash
+echo "GEMINI_API_KEY=your_api_key" > .env
+```
+
+🧩 **Knowledge Embeddings**
+
+Before running the app, generate embeddings from your knowledge PDFs:
+
+```bash
+python rag.py
+```
+Place relevant research papers or notes in the knowledge/ folder before running the above command.
+
+🖥️ **Usage**
+
+Launch the Gradio interface:
+```bash
+python main.py
+```
+Then:
+
+1. **Upload** an EEG CSV file (e.g., `EEGDATA.csv`).  
+2. **View** sleep stage visualizations, HMM clusters, and frequency spectra.  
+3. **Interact** with the **"Chat with NeuroNap"** feature to get context-aware insights.  
+4. **Download** processed data and reports in **CSV** or **PDF** format.  
+
+## 📦 Requirements
+
+- **Python 3.9+**  
+- See `requirements.txt` for the full dependency list  
+

faiss_index/index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f582048dd219190525d0df43072f7dbbc125963dd429eb92acaa45cc0f8b0c2
+size 1379373

faiss_index/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b7c9149372c508c2578ed9d0507107989e8e8ebd45717fe9ad51d7830278762
+size 928310

knowledge/eeg_sig_proc.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:566380955227b608de4fdc0fdd7e93ba85d11ed34c11e8b97fbd6301e78a5a44
+size 3598747

main.py

@@ -0,0 +1,146 @@
+import gradio as gr
+import pandas as pd
+from processing import process_eeg
+from visuals import plot_eeg_signals, plot_hypnogram, plot_frequency_spectra, plot_band_waveforms
+from rag import setup_rag, chat_with_llm, update_vectorstore_with_user_results
+import os
+import logging
+
+# Configure logger
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('neuronap.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def analyze_eeg(file):
+    logger.info("Starting EEG analysis")
+    if file is None:
+        logger.error("No CSV file uploaded")
+        raise ValueError("No CSV file uploaded.")
+    file_path = file.name
+    logger.info(f"Processing file: {file_path}")
+    eeg_uv, eeg_uv_bp, eeg_uv_notched, hypno, stats, features_df, hmm_labels, fs, time_s = process_eeg(file_path)
+    logger.info("EEG processing completed")
+    signals_img = plot_eeg_signals(time_s, eeg_uv, eeg_uv_bp, eeg_uv_notched)
+    hypno_img = plot_hypnogram(hypno)
+    spectra_img = plot_frequency_spectra(eeg_uv_notched, fs)
+    bands_img = plot_band_waveforms(eeg_uv_notched, fs)
+    
+    # Define key metrics with human-readable names for interface preview
+    key_metrics = {
+        'TST': 'Total Sleep Time (minutes)',
+        'SE': 'Sleep Efficiency (%)',
+        'REM': 'REM Sleep (minutes)',
+        'N3': 'Deep Sleep (N3) (minutes)',
+        'WASO': 'Wake After Sleep Onset (minutes)'
+    }
+    
+    # Format stats preview for interface default view
+    stats_preview = {k: stats.get(k) for k in key_metrics.keys() if k in stats}
+    stats_preview_str = "\n".join([
+        f"• {key_metrics[k]}: {v:.2f} {'%' if k in ['SE', '%N1', '%N2', '%N3', '%REM', '%NREM', 'SME'] else 'minutes'}"
+        for k, v in stats_preview.items()
+    ])
+    
+    # Format full stats for user_results.txt
+    stats_full_str = "\n".join([
+        f"• {k.replace('_', ' ').title()}: {v:.2f} {'%' if k in ['SE', '%N1', '%N2', '%N3', '%REM', '%NREM', 'SME'] else 'minutes'}"
+        for k, v in stats.items()
+    ])
+    
+    # Full stats table for interface expanded view
+    stats_full = pd.DataFrame(list(stats.items()), columns=['Metric', 'Value']).to_html(classes='stats-table', index=False)
+    
+    # Include full stats in user_results for saving to file
+    user_results = f"Sleep Statistics:\n{stats_full_str}\nHypnogram: {hypno}\n"
+    logger.info("Updating vectorstore with user results")
+    vectorstore = update_vectorstore_with_user_results(user_results)
+    qa_chain = setup_rag()
+    
+    # Generate previews and full tables for features and clusters
+    features_preview = features_df.head(5).to_html(classes='compact-table')
+    features_full = features_df.to_html(classes='compact-table')
+    clusters_preview = pd.DataFrame({'Cluster': hmm_labels}).head(5).to_html(classes='compact-table')
+    clusters_full = pd.DataFrame({'Cluster': hmm_labels}).to_html(classes='compact-table')
+    
+    logger.info("Analysis completed, returning outputs")
+    return (
+        signals_img, hypno_img, spectra_img, bands_img, stats_preview_str, stats_full,
+        features_preview, features_full, clusters_preview, clusters_full,
+        qa_chain,
+        "clean_eeg.csv", "features.csv", "eeg_clusters.csv",
+        "eeg_signal_plot.pdf", "hypnogram_plot.pdf", "eeg_fft_welch.pdf", "eeg_bands_plot.pdf"
+    )
+
+def handle_chat(query, qa_chain):
+    logger.info(f"Handling chat query: {query}")
+    if not query or qa_chain is None:
+        logger.warning("Invalid query or no QA chain available")
+        return "Please analyze an EEG file first and provide a query."
+    return chat_with_llm(query, qa_chain)
+
+with gr.Blocks(title="NeuroNap", css=".compact-table { font-size: 12px; max-height: 300px; overflow-y: auto; } .stats-table { font-size: 14px; border-collapse: collapse; width: 50%; } .stats-table th, .stats-table td { border: 1px solid #ddd; padding: 8px; text-align: left; }") as demo:
+    logger.info("Initializing Gradio interface")
+    qa_chain_state = gr.State(None)
+    gr.Markdown("# NeuroNap: EEG Sleep Monitoring System")
+    with gr.Column():
+        with gr.Row():
+            file_input = gr.File(label="Upload EEG CSV (e.g., EEGDATA.CSV)")
+            analyze_btn = gr.Button("Analyze")
+        with gr.Row():
+            signals_output = gr.Image(label="EEG Signals")
+            hypno_output = gr.Image(label="Hypnogram")
+        with gr.Row():
+            spectra_output = gr.Image(label="Frequency Spectra")
+            bands_output = gr.Image(label="Frequency Bands")
+        with gr.Group():
+            gr.Markdown("### Sleep Statistics")
+            stats_preview_output = gr.Textbox(label="Key Sleep Statistics")
+            with gr.Accordion("Show All Sleep Statistics", open=False):
+                stats_full_output = gr.HTML(label="Full Statistics")
+        with gr.Group():
+            gr.Markdown("### Extracted Features")
+            features_preview_output = gr.HTML(label="Features Preview")
+            with gr.Accordion("Show Full Features Table", open=False):
+                features_full_output = gr.HTML(label="Full Features")
+        with gr.Group():
+            gr.Markdown("### HMM Clusters")
+            clusters_preview_output = gr.HTML(label="Clusters Preview")
+            with gr.Accordion("Show Full Clusters Table", open=False):
+                clusters_full_output = gr.HTML(label="Full Clusters")
+        with gr.Group():
+            gr.Markdown("### Chat with NeuroNap")
+            chat_input = gr.Textbox(label="Ask about your sleep data", lines=2)
+            chat_btn = gr.Button("Send")
+            chat_output = gr.Textbox(label="LLM Response", lines=4)
+        with gr.Group():
+            gr.Markdown("### Downloads")
+            with gr.Row():
+                clean_csv = gr.File(label="Download clean_eeg.csv")
+                features_csv = gr.File(label="Download features.csv")
+                clusters_csv = gr.File(label="Download eeg_clusters.csv")
+            with gr.Row():
+                signals_pdf = gr.File(label="Download eeg_signal_plot.pdf")
+                hypno_pdf = gr.File(label="Download hypnogram_plot.pdf")
+                spectra_pdf = gr.File(label="Download eeg_fft_welch.pdf")
+                bands_pdf = gr.File(label="Download eeg_bands_plot.pdf")
+    
+    analyze_btn.click(
+        analyze_eeg,
+        inputs=file_input,
+        outputs=[
+            signals_output, hypno_output, spectra_output, bands_output, 
+            stats_preview_output, stats_full_output,
+            features_preview_output, features_full_output, clusters_preview_output, clusters_full_output,
+            qa_chain_state, clean_csv, features_csv, clusters_csv, signals_pdf, hypno_pdf, spectra_pdf, bands_pdf
+        ]
+    )
+    chat_btn.click(handle_chat, inputs=[chat_input, qa_chain_state], outputs=chat_output)
+
+logger.info("Launching Gradio interface")
+demo.launch(share=True)

processing.py

@@ -0,0 +1,179 @@
+import pandas as pd
+import numpy as np
+from scipy.signal import butter, filtfilt, iirnotch, welch, hilbert
+from scipy.interpolate import interp1d
+import yasa
+import mne
+import antropy as ant
+from sklearn.decomposition import PCA
+from hmmlearn.hmm import GaussianHMM
+from sklearn.preprocessing import StandardScaler
+import logging
+import os
+
+# Configure logger
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('neuronap.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def butter_bandpass(lowcut, highcut, fs, order=2):
+    nyquist = 0.5 * fs
+    low = lowcut / nyquist
+    high = highcut / nyquist
+    b, a = butter(order, [low, high], btype='band')
+    logger.info(f"Created bandpass filter: {lowcut}-{highcut} Hz, order={order}")
+    return b, a
+
+def detect_spindles(epoch, fs, low=12, high=16, threshold=1.0, min_duration=0.3):
+    b, a = butter(4, [low/(fs/2), high/(fs/2)], btype='band')
+    sig = filtfilt(b, a, epoch)
+    env = np.abs(hilbert(sig))
+    thresh_val = np.mean(env) + threshold * np.std(env)
+    mask = env > thresh_val
+    spindle_times = []
+    in_spindle = False
+    start = 0
+    for i, val in enumerate(mask):
+        if val and not in_spindle:
+            start = i
+            in_spindle = True
+        elif not val and in_spindle:
+            end = i
+            if (end - start) / fs >= min_duration:
+                spindle_times.append(start)
+            in_spindle = False
+    logger.info(f"Detected {len(spindle_times)} spindles in epoch")
+    return len(spindle_times)
+
+def detect_slow_waves(epoch, fs, low=0.5, high=2, threshold=1.0, min_duration=0.2):
+    b, a = butter(4, [low/(fs/2), high/(fs/2)], btype='band')
+    sig = filtfilt(b, a, epoch)
+    amp = np.abs(sig)
+    thresh_val = np.mean(amp) + threshold * np.std(amp)
+    mask = amp > thresh_val
+    slow_wave_times = []
+    in_wave = False
+    start = 0
+    for i, val in enumerate(mask):
+        if val and not in_wave:
+            start = i
+            in_wave = True
+        elif not val and in_wave:
+            end = i
+            if (end - start) / fs >= min_duration:
+                slow_wave_times.append(start)
+            in_wave = False
+    logger.info(f"Detected {len(slow_wave_times)} slow waves in epoch")
+    return len(slow_wave_times)
+
+def extract_features(epochs, fs):
+    logger.info(f"Extracting features from {len(epochs)} epochs")
+    features = []
+    for ep in epochs:
+        f, psd = welch(ep, fs=fs, nperseg=fs*4)
+        total_power = np.sum(psd)
+        delta = np.sum(psd[(f >= 0.5) & (f < 4)])
+        theta = np.sum(psd[(f >= 4) & (f < 8)])
+        alpha = np.sum(psd[(f >= 8) & (f < 13)])
+        sigma = np.sum(psd[(f >= 12) & (f < 16)])
+        beta = np.sum(psd[(f >= 13) & (f < 32)])
+        rel_delta = delta / total_power if total_power else 0
+        rel_theta = theta / total_power if total_power else 0
+        rel_alpha = alpha / total_power if total_power else 0
+        rel_sigma = sigma / total_power if total_power else 0
+        rel_beta = beta / total_power if total_power else 0
+        samp_entropy = ant.sample_entropy(ep)
+        spindle_count = detect_spindles(ep, fs)
+        slow_wave_count = detect_slow_waves(ep, fs)
+        features.append([rel_delta, rel_theta, rel_alpha, rel_sigma, rel_beta, samp_entropy, spindle_count, slow_wave_count])
+    feature_names = ['rel_delta', 'rel_theta', 'rel_alpha', 'rel_sigma', 'rel_beta', 'sample_entropy', 'spindle_count', 'slow_wave_count']
+    features_df = pd.DataFrame(features, columns=feature_names)
+    features_df.to_csv('features.csv', index=False)
+    logger.info("Saved features to features.csv")
+    return features_df
+
+def process_eeg(file_path):
+    logger.info(f"Processing EEG file: {file_path}")
+    if not os.path.exists(file_path):
+        logger.error(f"CSV file not found: {file_path}")
+        raise FileNotFoundError(f"CSV file not found: {file_path}")
+    df = pd.read_csv(file_path)
+    if 'time_ms' not in df.columns or 'adc_value' not in df.columns:
+        logger.error("CSV must contain 'time_ms' and 'adc_value' columns")
+        raise ValueError("CSV must contain 'time_ms' and 'adc_value' columns")
+    adc_values = pd.to_numeric(df['adc_value'], errors='coerce').values
+    time_ms = pd.to_numeric(df['time_ms'], errors='coerce').values
+    mask = ~np.isnan(adc_values) & ~np.isnan(time_ms)
+    adc_values = adc_values[mask]
+    time_ms = time_ms[mask]
+    logger.info(f"Loaded {len(adc_values)} valid data points")
+    v_ref = 3.3
+    gain = 15000
+    voltage_raw = adc_values * (v_ref / 4095)
+    estimated_bias = np.mean(voltage_raw)
+    voltage = voltage_raw - estimated_bias
+    eeg_uv = voltage * 1e6 / gain
+    df_res = pd.DataFrame({'time_ms': time_ms, 'adc_vals': adc_values})
+    df_clean = df_res.groupby('time_ms', as_index=False).agg({'adc_vals': 'mean'})
+    sample_rate_hz = 256
+    delta_ms = 1000 / sample_rate_hz
+    min_time = df_clean['time_ms'].min()
+    max_time = df_clean['time_ms'].max()
+    new_times = np.arange(min_time, max_time + delta_ms, delta_ms)
+    interpolator = interp1d(df_clean['time_ms'], df_clean['adc_vals'], kind='linear', fill_value='extrapolate')
+    new_adc_vals = interpolator(new_times)
+    df_res = pd.DataFrame({'time_ms': new_times, 'adc_vals': new_adc_vals})
+    voltage = (df_res['adc_vals'] * (v_ref / 4095)) - estimated_bias
+    eeg_uv = voltage * 1e6 / gain
+    df_res['time_s'] = df_res['time_ms'] / 1000
+    df_res['eeg_uv'] = eeg_uv
+    fs = 256.0
+    lowcut = 0.5
+    highcut = 30.0
+    nyquist = 0.5 * fs
+    low = lowcut / nyquist
+    high = highcut / nyquist
+    b, a = butter(2, [low, high], btype='band')
+    eeg_uv_bp = filtfilt(b, a, eeg_uv)
+    logger.info("Applied bandpass filter (0.5-30 Hz)")
+    notch_freq = 50.0
+    q = 30.0
+    b_notch, a_notch = iirnotch(notch_freq, q, fs)
+    eeg_uv_notched = filtfilt(b_notch, a_notch, eeg_uv_bp)
+    logger.info("Applied notch filter (50 Hz)")
+    clean_eeg = pd.DataFrame({'time_s': df_res['time_s'], 'eeg_uv': eeg_uv, 'eeg_bpf': eeg_uv_bp, 'eeg_notch': eeg_uv_notched})
+    clean_eeg.to_csv('clean_eeg.csv', index=False)
+    logger.info("Saved clean EEG data to clean_eeg.csv")
+    info = mne.create_info(ch_names=['Fz'], sfreq=fs, ch_types=['eeg'])
+    raw = mne.io.RawArray(eeg_uv_notched.reshape(1, -1), info)
+    sl = yasa.SleepStaging(raw, eeg_name='Fz')
+    hypno = sl.predict()
+    logger.info("Completed YASA sleep staging")
+    epoch_length = int(30 * fs)
+    num_epochs = len(eeg_uv_notched) // epoch_length
+    epochs = eeg_uv_notched[:num_epochs * epoch_length].reshape(num_epochs, epoch_length)
+    features_df = extract_features(epochs, fs)
+    scaler = StandardScaler()
+    features_scaled = scaler.fit_transform(features_df)
+    pca = PCA(n_components=5)
+    features_pca = pca.fit_transform(features_scaled)
+    logger.info("Applied PCA with 5 components")
+    model = GaussianHMM(n_components=5, covariance_type="full", n_iter=2000, tol=1e-6, random_state=42)
+    model.fit(features_pca)
+    hmm_labels = model.predict(features_pca)
+    logger.info("Completed HMM clustering")
+    clustered_features = features_df.copy()
+    clustered_features['cluster'] = hmm_labels
+    clustered_features.to_csv('eeg_clusters.csv', index=False)
+    logger.info("Saved clustered features to eeg_clusters.csv")
+    hypno_int = yasa.hypno_str_to_int(hypno)
+    sf_hyp = 1 / 30
+    stats = yasa.sleep_statistics(hypno_int, sf_hyp)
+    logger.info("Computed sleep statistics")
+    return eeg_uv, eeg_uv_bp, eeg_uv_notched, hypno, stats, features_df, hmm_labels, fs, df_res['time_s'].values

rag.py

@@ -0,0 +1,133 @@
+import os
+import glob
+from dotenv import load_dotenv
+from langchain_community.document_loaders import PyPDFLoader, TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_google_genai import ChatGoogleGenerativeAI
+import logging
+
+# Configure logger
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('neuronap.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+os.environ["GOOGLE_API_KEY"] = os.getenv("GEMINI_API_KEY", "")
+if not os.environ["GOOGLE_API_KEY"]:
+    logger.error("GEMINI_API_KEY not found in .env file")
+    raise ValueError("GEMINI_API_KEY not found in .env file")
+logger.info("Loaded environment variables")
+
+# Initialize embeddings and text splitter
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+try:
+    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+    logger.info("Initialized sentence-transformers embeddings")
+except Exception as e:
+    logger.error(f"Failed to initialize embeddings: {e}")
+    raise
+
+def create_knowledge_embeddings():
+    logger.info("Starting creation of knowledge embeddings")
+    knowledge_files = glob.glob("knowledge/*.pdf")
+    if not knowledge_files:
+        logger.error("No .pdf files found in 'knowledge' folder")
+        raise FileNotFoundError("No .pdf files found in 'knowledge' folder.")
+    
+    all_docs = []
+    for file_path in knowledge_files:
+        try:
+            logger.info(f"Loading PDF: {file_path}")
+            loader = PyPDFLoader(file_path)
+            documents = loader.load()
+            texts = text_splitter.split_documents(documents)
+            all_docs.extend(texts)
+            logger.info(f"Successfully loaded and split {file_path} with {len(texts)} chunks")
+        except Exception as e:
+            logger.error(f"Error loading {file_path}: {e}")
+    
+    if not all_docs:
+        logger.error("No valid documents loaded from knowledge folder")
+        raise ValueError("No valid documents loaded from knowledge folder.")
+    
+    logger.info(f"Creating FAISS index with {len(all_docs)} document chunks")
+    try:
+        vectorstore = FAISS.from_documents(all_docs, embeddings)
+        vectorstore.save_local("faiss_index")
+        logger.info("FAISS embeddings created and saved to 'faiss_index'")
+    except Exception as e:
+        logger.error(f"Error creating FAISS index: {e}")
+        raise
+
+def load_vectorstore():
+    logger.info("Loading FAISS vectorstore")
+    if not os.path.exists("faiss_index"):
+        logger.error("FAISS index not found")
+        raise FileNotFoundError("FAISS index not found. Run create_knowledge_embeddings first.")
+    vectorstore = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)
+    logger.info("FAISS vectorstore loaded successfully")
+    return vectorstore
+
+def update_vectorstore_with_user_results(user_results):
+    logger.info("Updating vectorstore with user results")
+    vectorstore = load_vectorstore()
+    with open("user_results.txt", "w", encoding="utf-8") as f:
+        f.write(user_results)
+    user_loader = TextLoader("user_results.txt")
+    user_docs = user_loader.load()
+    user_texts = text_splitter.split_documents(user_docs)
+    vectorstore.add_documents(user_texts)
+    vectorstore.save_local("faiss_index")
+    logger.info("User results added to vectorstore and saved")
+    return vectorstore
+
+def setup_rag():
+    logger.info("Setting up RAG chain")
+    try:
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0.5)
+        logger.info("Initialized Gemini 2.0 Flash LLM")
+    except Exception as e:
+        logger.error(f"Error initializing LLM: {e}. Check GEMINI_API_KEY or quota")
+        raise
+    vectorstore = load_vectorstore()
+    prompt_template = """\
+You are an expert assistant in EEG-based sleep analysis. Use the provided context from sleep stage definitions, EEG characteristics, and user-specific results to answer the query.
+Context: {context}
+User Query: {question}
+Provide a clear, educational response in plain text, avoiding Markdown symbols (e.g., **, *). Use bullet points (•) for lists and exact values from user data if referenced. Include concise explanations for each metric or finding.
+"""
+    PROMPT = PromptTemplate(template=prompt_template, input_variables=["context", "question"])
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=vectorstore.as_retriever(),
+        return_source_documents=True,
+        chain_type_kwargs={"prompt": PROMPT}
+    )
+    logger.info("RAG chain setup completed")
+    return qa_chain
+
+def chat_with_llm(query, qa_chain):
+    logger.info(f"Processing query: {query}")
+    try:
+        result = qa_chain({"query": query})["result"]
+        logger.info("Query processed successfully")
+        return result
+    except Exception as e:
+        logger.error(f"Error processing query: {e}")
+        return f"Error processing query: {e}. Check GEMINI_API_KEY or quota"
+
+if __name__ == "__main__":
+    logger.info("Running rag.py as main script")
+    os.makedirs("knowledge", exist_ok=True)
+    create_knowledge_embeddings()

requirements.txt

@@ -0,0 +1,20 @@
+gradio
+pandas
+numpy
+scipy
+matplotlib
+yasa
+mne
+antropy
+hmmlearn
+scikit-learn
+langchain
+langchain-google-genai
+google-generativeai
+langchain-community
+langchain-huggingface
+faiss-cpu
+python-dotenv
+pillow
+pypdf
+sentence-transformers

visuals.py

@@ -0,0 +1,123 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import yasa
+import io
+from PIL import Image
+from processing import butter_bandpass, filtfilt
+import logging
+
+# Configure logger
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('neuronap.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def plot_eeg_signals(time_s, eeg_uv, eeg_uv_bp, eeg_uv_notched):
+    logger.info("Generating EEG signals plot")
+    plt.figure(figsize=(12, 8))
+    plt.plot(time_s, eeg_uv, label='Raw EEG (µV)', alpha=0.5)
+    plt.plot(time_s, eeg_uv_bp, label='Bandpass EEG (0.5-30 Hz)', linewidth=2)
+    plt.plot(time_s, eeg_uv_notched, label='Notched EEG (50 Hz)', linewidth=2, linestyle='--')
+    plt.title("EEG Signal: Raw vs Filtered", fontsize=42)
+    plt.xlabel("Time (s)", fontsize=36)
+    plt.ylabel("Amplitude (µV)", fontsize=36)
+    plt.xticks(fontsize=28)
+    plt.yticks(fontsize=28)
+    plt.grid(True)
+    plt.legend(fontsize=18.5, loc='upper right')  # Explicit loc to avoid warning
+    plt.tight_layout()
+    plt.savefig("eeg_signal_plot.pdf", format='pdf', dpi=300)
+    logger.info("Saved EEG signals plot to eeg_signal_plot.pdf")
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    return img
+
+def plot_frequency_spectra(eeg_uv_notched, fs):
+    logger.info("Generating frequency spectra plot")
+    from scipy.signal import welch
+    f_welch, psd_welch = welch(eeg_uv_notched, fs, nperseg=1024, noverlap=512)
+    plt.figure(figsize=(12, 12))
+    plt.subplot(2,1,1)
+    n = len(eeg_uv_notched)
+    freqs_fft = np.fft.fftfreq(n, d=1/fs)
+    fft_magnitude = np.abs(np.fft.fft(eeg_uv_notched)) / n
+    plt.plot(freqs_fft[:n//2], fft_magnitude[:n//2] * 2, linewidth=2)
+    plt.title("FFT Spectrum", fontsize=28)
+    plt.xlabel("Frequency (Hz)", fontsize=24)
+    plt.ylabel("Magnitude (µV)", fontsize=24)
+    plt.grid(True)
+    plt.subplot(2,1,2)
+    plt.semilogy(f_welch, psd_welch, linewidth=2)
+    plt.title("Welch PSD", fontsize=28)
+    plt.xlabel("Frequency (Hz)", fontsize=24)
+    plt.ylabel("Power/Frequency (µV²/Hz)", fontsize=24)
+    plt.grid(True)
+    plt.tight_layout()
+    plt.savefig("eeg_fft_welch.pdf", format='pdf', dpi=300)
+    logger.info("Saved frequency spectra plot to eeg_fft_welch.pdf")
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    return img
+
+def plot_band_waveforms(eeg_uv_notched, fs, start_s=3000, end_s=3020):
+    logger.info("Generating frequency bands plot")
+    time_s = np.arange(len(eeg_uv_notched)) / fs
+    mask = (time_s >= start_s) & (time_s <= end_s)
+    window = eeg_uv_notched[mask]
+    time_window = time_s[mask]
+    eeg_delta = filtfilt(*butter_bandpass(0.5, 4, fs), window)
+    eeg_theta = filtfilt(*butter_bandpass(4, 8, fs), window)
+    eeg_alpha = filtfilt(*butter_bandpass(8, 13, fs), window)
+    eeg_beta = filtfilt(*butter_bandpass(13, 30, fs), window)
+    plt.figure(figsize=(16, 18))
+    plt.subplot(4,1,1); plt.plot(time_window, eeg_delta, linewidth=2); plt.title("Delta (0.5-4 Hz)", fontsize=28)
+    plt.subplot(4,1,2); plt.plot(time_window, eeg_theta, linewidth=2); plt.title("Theta (4-8 Hz)", fontsize=28)
+    plt.subplot(4,1,3); plt.plot(time_window, eeg_alpha, linewidth=2); plt.title("Alpha (8-13 Hz)", fontsize=28)
+    plt.subplot(4,1,4); plt.plot(time_window, eeg_beta, linewidth=2); plt.title("Beta (13-30 Hz)", fontsize=28)
+    plt.tight_layout()
+    plt.savefig("eeg_bands_plot.pdf", format='pdf', dpi=300)
+    logger.info("Saved frequency bands plot to eeg_bands_plot.pdf")
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    return img
+
+def plot_hypnogram(hypno):
+    logger.info("Generating hypnogram plot")
+    hypno_int = yasa.hypno_str_to_int(hypno)
+    time_minutes = np.arange(len(hypno_int)) * 0.5
+    start_min, end_min = 40, 170
+    start_epoch = int(start_min / 0.5)
+    end_epoch = int(end_min / 0.5)
+    window_time = time_minutes[start_epoch:end_epoch]
+    window_hypno = hypno_int[start_epoch:end_epoch]
+    plt.figure(figsize=(16, 6))
+    plt.step(window_time, window_hypno, where='post', color='navy', linewidth=3)
+    plt.gca().invert_yaxis()
+    plt.yticks([4, 3, 2, 1, 0], ['W', 'N1', 'N2', 'N3', 'R'], fontsize=28)
+    plt.xlabel('Time (minutes)', fontsize=32)
+    plt.ylabel('Sleep Stage', fontsize=32)
+    plt.title(f'Hypnogram ({start_min}-{end_min} min)', fontsize=36)
+    plt.grid(axis='x', linestyle='--', alpha=0.5)
+    plt.tight_layout()
+    plt.savefig("hypnogram_plot.pdf", format='pdf', dpi=300)
+    logger.info("Saved hypnogram to hypnogram_plot.pdf")
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    return img