File size: 4,233 Bytes
5fdbc81 13f97c3 5fdbc81 13f97c3 5fdbc81 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 |
import mne
import streamlit as st
import matplotlib.pyplot as plt
from braindecode import EEGClassifier
from braindecode.models import Deep4Net,ShallowFBCSPNet,EEGNetv4, TCN
from braindecode.training.losses import CroppedLoss
import torch
import numpy as np
def set_button_state(output,col):
# Generate a random output value of 0 or 1
# output = 2023 #random.randint(0, 1)
# Store the output value in session state
st.session_state.output = output
# Define the button color and text based on the output value
if st.session_state.output == 0:
button_color = "green"
button_text = "Normal"
elif st.session_state.output == 1:
button_color = "red"
button_text = "Abnormal"
# elif st.session_state.output == 3:
# button_color = "yellow"
# button_text = "Waiting"
else:
button_color = "gray"
button_text = "Unknown"
# Create a custom HTML button with CSS styling
col.markdown(f"""
<style>
.custom-button {{
background-color: {button_color};
color: black;
padding: 10px 20px;
border: none;
border-radius: 5px;
cursor: pointer;
}}
</style>
<button class="custom-button">Output: {button_text}</button>
""", unsafe_allow_html=True)
def predict(raw,clf):
x = np.expand_dims(raw.get_data()[:21, :6000], axis=0)
output = clf.predict(x)
return output
def build_model(model_name, n_classes, n_chans, input_window_samples, drop_prob=0.5, lr=0.01):#, weight_decay, batch_size, n_epochs, wandb_run, checkpoint, optimizer__param_groups, window_train_set, window_val):
n_start_chans = 25
final_conv_length = 1
n_chan_factor = 2
stride_before_pool = True
# input_window_samples =6000
model = Deep4Net(
n_chans, n_classes,
n_filters_time=n_start_chans,
n_filters_spat=n_start_chans,
input_window_samples=input_window_samples,
n_filters_2=int(n_start_chans * n_chan_factor),
n_filters_3=int(n_start_chans * (n_chan_factor ** 2.0)),
n_filters_4=int(n_start_chans * (n_chan_factor ** 3.0)),
final_conv_length=final_conv_length,
stride_before_pool=stride_before_pool,
drop_prob=drop_prob)
clf = EEGClassifier(
model,
cropped=True,
criterion=CroppedLoss,
# criterion=CroppedLoss_sd,
criterion__loss_function=torch.nn.functional.nll_loss,
optimizer=torch.optim.AdamW,
optimizer__lr=lr,
iterator_train__shuffle=False,
# iterator_train__sampler = ImbalancedDatasetSampler(window_train_set, labels=window_train_set.get_metadata().target),
# batch_size=batch_size,
callbacks=[
# EarlyStopping(patience=5),
# StochasticWeightAveraging(swa_utils, swa_start=1, verbose=1, swa_lr=lr),
# "accuracy", "balanced_accuracy","f1",("lr_scheduler", LRScheduler('CosineAnnealingLR', T_max=n_epochs - 1)),
# checkpoint,
], #"accuracy",
# device='cuda'
)
clf.initialize()
pt_path = './Deep4Net_trained_tuh_scaling_wN_WAug_DefArgs_index8_number2700_state_dict_100.pt'
clf.load_params(f_params=pt_path)
return clf
def preprocessing_and_plotting(raw):
# Select the first channel
channel = raw.ch_names[0]
st.write(f"Selected channel: {channel}")
# Plot the first channel
fig, ax = plt.subplots()
ax.plot(raw.times, raw[channel][0].T)
ax.set_xlabel("Time (s)")
ax.set_ylabel("Amplitude (µV)")
ax.set_title(f"EEG signal of {channel}")
st.pyplot(fig)
def read_file(edf_file):
# To read file as bytes:
bytes_data = edf_file.getvalue()
# Open a file named "output.bin" in the current directory in write binary mode
with open('edf_file.edf', "wb") as f:
# Write the bytes data to the file
f.write(bytes_data)
raw = mne.io.read_raw_edf('edf_file.edf')
st.write(f"Loaded {edf_file.name} with {raw.info['nchan']} channels")
return raw
|