app.py

import gradio as gr
import pandas as pd
import numpy as np
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Load data
def load_data():
    """Load the dataset from a local CSV file"""
    df = pd.read_csv("EEG_Eye_State.csv")
    return df

# Initialize data
df = load_data()

# List of EEG channels
eeg_channels = ['AF3', 'F7', 'F3', 'FC5', 'T7', 'P7', 'O1', 
                'O2', 'P8', 'T8', 'FC6', 'F4', 'F8', 'AF4']

def plot_eeg_signals(start_time, duration, eye_state_filter, selected_channels):
    """
    Visualize the selected EEG signals
    """
    # Calculate indices based on time (128 Hz)
    sampling_rate = 128
    start_idx = int(start_time * sampling_rate)
    end_idx = start_idx + int(duration * sampling_rate)
    
    # Filter data segment
    df_segment = df.iloc[start_idx:end_idx].copy()
    
    # Filter by eye state if selected
    if eye_state_filter != "Both":
        filter_value = 1 if eye_state_filter == "Closed" else 0
        df_segment = df_segment[df_segment['eyeDetection'] == filter_value]
    
    if len(df_segment) == 0:
        return None
    
    # Create subplots
    n_channels = len(selected_channels)
    fig = make_subplots(
        rows=n_channels, 
        cols=1,
        shared_xaxes=True,
        vertical_spacing=0.02,
        subplot_titles=selected_channels
    )
    
    # Create time axis
    time_axis = np.arange(len(df_segment)) / sampling_rate + start_time
    
    # Add each channell
    for idx, channel in enumerate(selected_channels, 1):
        # Color based on eye state
        colors = ['red' if x == 1 else 'blue' for x in df_segment['eyeDetection']]
        
        fig.add_trace(
            go.Scatter(
                x=time_axis,
                y=df_segment[channel],
                mode='lines',
                name=channel,
                line=dict(color='steelblue', width=1),
                showlegend=False
            ),
            row=idx, col=1
        )
        
        # Add shaded areas for closed eyes
        eye_closed_mask = df_segment['eyeDetection'] == 1
        if eye_closed_mask.any():
            closed_indices = np.where(eye_closed_mask)[0]
            # Group consecutive indices
            if len(closed_indices) > 0:
                groups = np.split(closed_indices, np.where(np.diff(closed_indices) != 1)[0] + 1)
                for group in groups:
                    if len(group) > 0:
                        fig.add_vrect(
                            x0=time_axis[group[0]],
                            x1=time_axis[group[-1]],
                            fillcolor="red", opacity=0.1,
                            layer="below", line_width=0,
                            row=idx, col=1
                        )
    
    # Update layout
    fig.update_xaxes(title_text="Time (seconds)", row=n_channels, col=1)
    fig.update_yaxes(title_text="Amplitude (μV)")
    
    fig.update_layout(
        height=200 * n_channels,
        title_text=f"EEG Signals - {eye_state_filter} Eyes",
        showlegend=False,
        hovermode='x unified'
    )
    
    return fig

def plot_channel_comparison(channels, eye_state_filter, remove_outliers):
    """
    Compare specific channels between open and closed eyes
    """
    if not channels:
        return None
    
    n_channels = len(channels)
    
    # Determine number of columns based on filter
    n_cols = 2 if eye_state_filter == "Both" else 1
    
    if eye_state_filter == "Both":
        subplot_titles = [f'{ch} - Eyes Open' if i % 2 == 0 else f'{ch} - Eyes Closed' 
                         for ch in channels for i in range(2)]
        specs = [[{'type': 'box'}, {'type': 'histogram'}] for _ in range(n_channels)]
    else:
        state_label = "Eyes Open" if eye_state_filter == "Open" else "Eyes Closed"
        subplot_titles = [f'{ch} - {state_label}' for ch in channels]
        specs = [[{'type': 'box'}] for _ in range(n_channels)]
    
    fig = make_subplots(
        rows=n_channels, cols=n_cols,
        subplot_titles=subplot_titles,
        specs=specs,
        vertical_spacing=0.08
    )
    
    for idx, channel in enumerate(channels, 1):
        df_open = df[df['eyeDetection'] == 0][channel]
        df_closed = df[df['eyeDetection'] == 1][channel]
        
        # Filter outliers if requested
        if remove_outliers:
            def filter_outliers(data):
                Q1 = data.quantile(0.25)
                Q3 = data.quantile(0.75)
                IQR = Q3 - Q1
                lower_bound = Q1 - 1.5 * IQR
                upper_bound = Q3 + 1.5 * IQR
                return data[(data >= lower_bound) & (data <= upper_bound)]
            
            df_open = filter_outliers(df_open)
            df_closed = filter_outliers(df_closed)
        
        if eye_state_filter in ["Both", "Open"]:
            # Boxplot for Open
            fig.add_trace(
                go.Box(y=df_open, name=f'{channel} Open', marker_color='blue', 
                       showlegend=(idx==1)),
                row=idx, col=1
            )
        
        if eye_state_filter in ["Both", "Closed"]:
            # Boxplot for Closed
            fig.add_trace(
                go.Box(y=df_closed, name=f'{channel} Closed', marker_color='red', 
                       showlegend=(idx==1)),
                row=idx, col=1
            )
        
        # Histogram only if "Both"
        if eye_state_filter == "Both":
            # Histograma Open
            fig.add_trace(
                go.Histogram(x=df_open, name=f'{channel} Open', marker_color='blue', 
                            opacity=0.7, showlegend=False, nbinsx=30),
                row=idx, col=2
            )
            # Histogram Closed
            fig.add_trace(
                go.Histogram(x=df_closed, name=f'{channel} Closed', marker_color='red', 
                            opacity=0.7, showlegend=False, nbinsx=30),
                row=idx, col=2
            )
            
            # Center and adjust histogram axes
            all_data = pd.concat([df_open, df_closed])
            data_min = all_data.min()
            data_max = all_data.max()
            data_range = data_max - data_min
            margin = data_range * 0.1
            
            fig.update_xaxes(
                range=[data_min - margin, data_max + margin],
                row=idx, col=2
            )
    
    fig.update_layout(
        height=350 * n_channels,
        title_text=f"Channel Distribution Comparison - {eye_state_filter} Eyes",
        showlegend=True
    )
    
    if eye_state_filter == "Both":
        fig.update_xaxes(title_text="Amplitude (μV)", row=n_channels, col=2)
    fig.update_yaxes(title_text="Amplitude (μV)")
    
    return fig

def get_statistics():
    """
    Generate dataset statistics in text format
    """
    stats = []
    
    # General information
    total_samples = len(df)
    eyes_open = len(df[df['eyeDetection'] == 0])
    eyes_closed = len(df[df['eyeDetection'] == 1])
    duration = total_samples / 128  # seconds
    
    stats.append(f"**Dataset Statistics**")
    stats.append(f"- Total samples: {total_samples:,}")
    stats.append(f"- Duration: {duration:.2f} seconds")
    stats.append(f"- Sampling rate: 128 Hz")
    stats.append(f"- Eyes Open samples: {eyes_open:,} ({eyes_open/total_samples*100:.1f}%)")
    stats.append(f"- Eyes Closed samples: {eyes_closed:,} ({eyes_closed/total_samples*100:.1f}%)")
    
    return "\n".join(stats)

def get_statistics_table():
    """
    Generate statistics table per channel
    """
    stats_data = []
    
    for channel in eeg_channels:
        channel_data = df[channel]
        open_data = df[df['eyeDetection'] == 0][channel]
        closed_data = df[df['eyeDetection'] == 1][channel]
        
        stats_data.append({
            'Channel': channel,
            'Mean (All)': f"{channel_data.mean():.2f}",
            'Std (All)': f"{channel_data.std():.2f}",
            'Mean (Open)': f"{open_data.mean():.2f}",
            'Mean (Closed)': f"{closed_data.mean():.2f}",
            'Min': f"{channel_data.min():.2f}",
            'Max': f"{channel_data.max():.2f}"
        })
    
    return pd.DataFrame(stats_data)

def plot_correlation_matrix():
    """
    Visualize the correlation matrix between channels
    """
    corr_matrix = df[eeg_channels].corr()
    
    fig = go.Figure(data=go.Heatmap(
        z=corr_matrix.values,
        x=eeg_channels,
        y=eeg_channels,
        colorscale='RdBu',
        zmid=0,
        text=corr_matrix.values,
        texttemplate='%{text:.2f}',
        textfont={"size": 9},
        colorbar=dict(title="Correlation")
    ))
    
    fig.update_layout(
        title={
            'text': "EEG Channels Correlation Matrix",
            'x': 0.5,
            'xanchor': 'center'
        },
        height=600,
        width=1215,
        xaxis={'side': 'bottom'}
    )
    
    return fig

# Create Gradio interface
demo = gr.Blocks(title="EEG Eye State Visualizer")

with demo:
    
    gr.Markdown("""
    # 🧠 EEG Eye State Visualizer
    
    Explore and visualize the EEG Eye State Classification Dataset. This interactive tool allows you to:
    - View EEG signals from 14 channels
    - Compare patterns between open and closed eyes
    - Analyze statistical distributions
    - Examine channel correlations
    
    **Dataset Info**: 14,980 samples | 128 Hz sampling rate | 14 EEG channels
    """)
    
    with gr.Tab("Signal Viewer"):
        gr.Markdown("### Visualize EEG Signals")
        
        with gr.Row():
            with gr.Column(scale=1):
                start_time = gr.Slider(
                    minimum=0, 
                    maximum=117, 
                    value=0, 
                    step=0.5,
                    label="Start Time (seconds)"
                )
                duration = gr.Slider(
                    minimum=1, 
                    maximum=10, 
                    value=5, 
                    step=0.5,
                    label="Duration (seconds)"
                )
                eye_state = gr.Radio(
                    choices=["Both", "Open", "Closed"],
                    value="Both",
                    label="Eye State Filter"
                )
                channels = gr.CheckboxGroup(
                    choices=eeg_channels,
                    value=['AF3', 'F7', 'O1', 'O2'],
                    label="Select Channels to Display"
                )
                plot_btn = gr.Button("Generate Plot", variant="primary")
            
            with gr.Column(scale=3):
                signal_plot = gr.Plot(label="EEG Signals")
        
        plot_btn.click(
            fn=plot_eeg_signals,
            inputs=[start_time, duration, eye_state, channels],
            outputs=signal_plot
        )
    
    with gr.Tab("Channel Analysis"):
        gr.Markdown("### Compare Multiple Channels")
        
        with gr.Row():
            with gr.Column(scale=1):
                channels_select = gr.CheckboxGroup(
                    choices=eeg_channels,
                    value=['AF3', 'O1'],
                    label="Select Channels to Compare"
                )
                eye_state_compare = gr.Radio(
                    choices=["Both", "Open", "Closed"],
                    value="Both",
                    label="Eye State Filter"
                )
                remove_outliers_check = gr.Checkbox(
                    label="Remove Outliers (IQR method)",
                    value=False
                )
                compare_btn = gr.Button("Analyze Channels", variant="primary")
            
            with gr.Column(scale=3):
                comparison_plot = gr.Plot(label="Channel Comparison")
        
        compare_btn.click(
            fn=plot_channel_comparison,
            inputs=[channels_select, eye_state_compare, remove_outliers_check],
            outputs=comparison_plot
        )
    
    with gr.Tab("Statistics"):
        gr.Markdown("### Dataset Statistics")
        
        stats_text = gr.Markdown(value=get_statistics())
        
        gr.Markdown("### Channel Statistics Table (μV)")
        stats_table = gr.Dataframe(
            value=get_statistics_table(),
            interactive=False,
            wrap=True
        )
        
        gr.Markdown("### Correlation Matrix")
        with gr.Row():
            corr_plot = gr.Plot(
                value=plot_correlation_matrix(), 
                container=True,
                scale=1
            )
    
    with gr.Tab("About"):
        gr.Markdown("""
        ## About this Dataset
        
        The EEG Eye State Classification Dataset contains continuous EEG measurements from 14 electrodes 
        collected during different eye states (open/closed).
        
        ### Key Features:
        - **Total Instances**: 14,980 observations
        - **Features**: 14 EEG channel measurements
        - **Sampling Rate**: 128 Hz
        - **Duration**: ~117 seconds
        - **Device**: Emotiv EEG Neuroheadset
        
        ### Electrode Placement:
        The 14 channels follow the international 10-20 system:
        - Left hemisphere: AF3, F7, F3, FC5, T7, P7, O1
        - Right hemisphere: O2, P8, T8, FC6, F4, F8, AF4
        
        ### Citation:
        ```
        Rösler, O. (2013). EEG Eye State. 
        UCI Machine Learning Repository. 
        https://doi.org/10.24432/C57G7J
        ```
        
        ### Links:
        - [Dataset on Hugging Face](https://huggingface.co/datasets/BrainSpectralAnalytics/eeg-eye-state-classification)
        - [Original UCI Repository](https://archive.ics.uci.edu/dataset/264/eeg+eye+state)
        - [Kaggle Example](https://www.kaggle.com/code/beta3logic/eye-state-eeg-classification-model-using-automl)
        """)

# Launch application
if __name__ == "__main__":
    demo.launch(ssr_mode=False)