Update README.md

README.md

@@ -1,3 +1,389 @@
----
-license: cc-by-nc-sa-4.0
----
+---
+license: cc-by-nc-sa-4.0
+---
+# bai-6 Emotion (TR)
+
+## Tanım
+
+bai-6 Emotion modeli, EEG ve iEEG tarafından toplanan veriler ile eğitilen bir detaylı duygu sınıflandırma modelidir.  Model, 6 kanallı bir EEG cihazıyla çalışabilir durumdadır.
+
+## Hedef Kitle
+
+bai modelleri, herkes için tasarlanmıştır. Açık kaynak versiyonları herkes tarafından kullanılabilir.
+
+## Sınıflar
+
+- Sakin
+- Üzgün
+- Kızgın
+- Mutlu
+
+## Neuramax
+
+Neuramax-6 Gen1 ile tam uyumlu çalışmaktadır.
+
+-------------------------------------------------------------------------
+# bai-6 Emotion (EN)
+
+## Definition
+
+The bai-6 Emotion model is a detailed emotion classification model trained with data collected by EEG and iEEG.  The model can work with a 6-channel EEG device.
+
+## Target Audience
+
+bai models are designed for everyone. Open source versions are available for everyone to use.
+
+## Classes
+
+- Calm
+- Sad
+- Angry
+- Happy
+
+## Neuramax
+
+Fully compatible with Neuramax-6 Gen1.
+
+-------------
+# bai-6 Emotion v1 Yapısı / Structure
+
+```bash
+"model_summary": 
+"Model:  Total params: 5,046 (19.71 KB) 
+               Trainable params: 5,044 (19.70 KB)
+               Non-trainable params: 0 (0.00 B)
+               Optimizer params: 2 (12.00 B)",
+  "layers": [
+    {
+      "name": "dense",
+      "trainable": true,
+      "count_params": 2368
+    },
+    {
+      "name": "dropout",
+      "trainable": true,
+      "count_params": 0
+    },
+    {
+      "name": "dense_1",
+      "trainable": true,
+      "count_params": 2080
+    },
+    {
+      "name": "dropout_1",
+      "trainable": true,
+      "count_params": 0
+    },
+    {
+      "name": "dense_2",
+      "trainable": true,
+      "count_params": 528
+    },
+    {
+      "name": "dense_3",
+      "trainable": true,
+      "count_params": 68
+    }
+  ]
+```
+
+# Kullanım / Usage
+
+## 1. Sentetik Veri ile / With Synthetic Data
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+import mne
+from matplotlib.animation import FuncAnimation
+from tensorflow.keras.models import load_model
+import joblib
+
+
+class EEGMonitor:
+    def __init__(self, model_path, scaler_path):
+        self.model = load_model(model_path)
+        self.scaler = joblib.load(scaler_path)
+        self.ch_names = ['T7', 'C3', 'Cz', 'C4', 'T8', 'Pz']
+        self.fs = 1000  # Örnekleme frekansı / Sampling frequency
+        self.buffer_size = 1000  # 1 saniyelik buffer / 1 second buffer
+
+        self.raw_buffer = np.zeros((6, self.buffer_size))
+        self.feature_contributions = {ch: [] for ch in self.ch_names}
+
+        # Elektrot pozisyonları (10-20 sistemi) / Electrode positions (10-20 system)
+        self.montage = mne.channels.make_standard_montage('standard_1020')
+
+        self.fig = plt.figure(figsize=(15, 10))
+        self.setup_plots()
+
+    def setup_plots(self):
+        self.ax1 = self.fig.add_subplot(223)
+        self.ax1.set_title("Canlı EEG Sinyalleri / Live EEG Signals")
+        self.ax1.set_xlabel("Zaman (ms) / Time (ms)")
+        self.ax1.set_ylabel("Amplitüd (µV) / Amplitude (µV)")
+
+        self.ax2 = self.fig.add_subplot(221)
+        self.ax2.set_title("Elektrot Konumları / Electrode Locations")
+
+        self.ax3 = self.fig.add_subplot(224)
+        self.ax3.set_title("Elektrot Katkı Oranları / Electrode Contribution Ratios")
+        self.ax3.set_ylim(0, 1)
+
+        self.ax4 = self.fig.add_subplot(222)
+        self.ax4.set_title("Duygu Tahmin Olasılıkları / Emotion Prediction Probabilities")
+        self.ax4.set_ylim(0, 1)
+
+        plt.tight_layout()
+
+    def generate_synthetic_data(self):
+        """Sentetik EEG verisi üretir (6 kanal x 1000 örnek) / Generates synthetic EEG data (6 channels x 1000 samples)"""
+        noise = np.random.normal(0, 5e-6, (6, self.buffer_size))
+
+        t = np.linspace(0, 1, self.buffer_size)
+        noise[1] += 2e-6 * np.sin(2 * np.pi * 10 * t)
+
+        return noise
+
+    def update_buffer(self, new_data):
+        """Buffer'ı kaydırmalı olarak günceller / Updates the buffer with new data by rolling"""
+        self.raw_buffer = np.roll(self.raw_buffer, -new_data.shape[1], axis=1)
+        self.raw_buffer[:, -new_data.shape[1]:] = new_data
+
+    def calculate_channel_contributions(self, features):
+        """Her elektrotun tahmindeki katkısını hesaplar / Calculates the contribution of each electrode to the prediction"""
+        contributions = np.zeros(6)
+        for i in range(6):
+            channel_weights = self.model.layers[0].get_weights()[0][i * 6:(i + 1) * 6]
+            contributions[i] = np.mean(np.abs(channel_weights))
+
+        return contributions / np.sum(contributions)
+
+    def update_plot(self, frame):
+        new_data = self.generate_synthetic_data()
+        self.update_buffer(new_data)
+
+        features = self.extract_features(self.raw_buffer)
+        scaled_features = self.scaler.transform([features])
+        probs = self.model.predict(scaled_features, verbose=0)[0]
+
+        contributions = self.calculate_channel_contributions(features)
+
+        self.update_eeg_plot()
+        self.update_topomap()
+        self.update_contributions(contributions)
+        self.update_probabilities(probs)
+
+    def update_eeg_plot(self):
+        self.ax1.clear()
+        for i in range(6):
+            offset = i * 20e-6
+            self.ax1.plot(self.raw_buffer[i] + offset, label=self.ch_names[i])
+        self.ax1.legend(loc='upper right')
+
+    def update_topomap(self):
+        self.ax2.clear()
+        info = mne.create_info(self.ch_names, self.fs, 'eeg')
+        evoked = mne.EvokedArray(self.raw_buffer.mean(axis=1, keepdims=True), info)
+        evoked.set_montage(self.montage)
+        mne.viz.plot_topomap(evoked.data[:, 0], evoked.info, axes=self.ax2, show=False)
+
+    def update_contributions(self, contributions):
+        self.ax3.clear()
+        self.ax3.barh(self.ch_names, contributions, color='skyblue')
+        for i, v in enumerate(contributions):
+            self.ax3.text(v, i, f"{v * 100:.1f}%", color='black')
+
+    def update_probabilities(self, probs):
+        emotions = ['Mutlu / Happy', 'Kızgın / Angry', 'Üzgün / Sad', 'Sakin / Calm']
+        self.ax4.clear()
+        bars = self.ax4.barh(emotions, probs, color=['green', 'red', 'blue', 'purple'])
+        for bar in bars:
+            width = bar.get_width()
+            self.ax4.text(width, bar.get_y() + 0.2, f"{width * 100:.1f}%", ha='left')
+
+    def extract_features(self, data):
+        """6 kanal için özellik çıkarımı / Feature extraction for 6 channels"""
+        features = []
+        for channel in data:
+            features.extend([
+                np.mean(channel),
+                np.std(channel),
+                np.ptp(channel),
+                np.sum(np.abs(np.diff(channel))),
+                np.median(channel),
+                np.percentile(np.abs(channel), 95)
+            ])
+        return np.array(features)
+
+    def start_monitoring(self):
+        anim = FuncAnimation(self.fig, self.update_plot, interval=100)
+        plt.show()
+
+
+if __name__ == "__main__":
+    monitor = EEGMonitor(
+        model_path='model/path/bai-6 Emotion.h5',
+        scaler_path='scaler/path/bai-6_scaler.save'
+    )
+    monitor.start_monitoring()
+```
+
+## 2. Veri Seti ile / With Dataset
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+import mne
+from matplotlib.animation import FuncAnimation
+from tensorflow.keras.models import load_model
+import joblib
+import os
+
+
+class EEGMonitor:
+    def __init__(self, model_path, scaler_path, data_path):
+        self.model = load_model(model_path)
+        self.scaler = joblib.load(scaler_path)
+        self.data_path = data_path
+        self.ch_names = ['T7', 'C3', 'Cz', 'C4', 'T8', 'Pz']
+        self.fs = 1000  # Örnekleme frekansı / Sampling frequency
+        self.buffer_size = 1000  # 1 saniyelik buffer / 1 second buffer
+
+        self.raw_buffer = np.zeros((6, self.buffer_size))
+        self.feature_contributions = {ch: [] for ch in self.ch_names}
+
+        # Elektrot pozisyonları / Electrode positions (10-20 system)
+        self.montage = mne.channels.make_standard_montage('standard_1020')
+
+        self.fig = plt.figure(figsize=(15, 10))
+        self.setup_plots()
+
+        self.dataset = self.load_dataset(self.data_path)
+        self.current_index = 0
+
+    def setup_plots(self):
+        self.ax1 = self.fig.add_subplot(223)
+        self.ax1.set_title("Canlı EEG Sinyalleri / Live EEG Signals")
+        self.ax1.set_xlabel("Zaman (ms) / Time (ms)")
+        self.ax1.set_ylabel("Amplitüd (µV) / Amplitude (µV)")
+
+        self.ax2 = self.fig.add_subplot(221)
+        self.ax2.set_title("Elektrot Konumları / Electrode Locations")
+
+        self.ax3 = self.fig.add_subplot(224)
+        self.ax3.set_title("Elektrot Katkı Oranları / Electrode Contribution Ratios")
+        self.ax3.set_ylim(0, 1)
+
+        self.ax4 = self.fig.add_subplot(222)
+        self.ax4.set_title("Duygu Tahmin Olasılıkları / Emotion Prediction Probabilities")
+        self.ax4.set_ylim(0, 1)
+
+        plt.tight_layout()
+
+    def load_dataset(self, path):
+        """Desteklenen veri formatları: .npy (numpy), .csv / Supported data formats: .npy (numpy), .csv"""
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Veri seti bulunamadı / Not found dataset: {path}")
+
+        if path.endswith(".npy"):
+            data = np.load(path)
+        elif path.endswith(".csv"):
+            data = np.loadtxt(path, delimiter=',')
+        else:
+            raise ValueError("Desteklenmeyen dosya formatı. Yalnızca .npy veya .csv kullanılabilir. / Unsupported file format. Only .npy or .csv can be used.")
+
+        # Transpose gerekebilir: (n_channels, n_samples) / Transpose may be needed: (n_channels, n_samples)
+        if data.shape[0] != 6:
+            data = data.T
+        return data
+
+    def get_next_chunk(self):
+        """Veri setinden buffer_size uzunluğunda bir parça alır / Gets a chunk of length buffer_size from the dataset"""
+        if self.current_index + self.buffer_size >= self.dataset.shape[1]:
+            self.current_index = 0
+        chunk = self.dataset[:, self.current_index:self.current_index + self.buffer_size]
+        self.current_index += self.buffer_size
+        return chunk
+
+    def update_buffer(self, new_data):
+        self.raw_buffer = np.roll(self.raw_buffer, -new_data.shape[1], axis=1)
+        self.raw_buffer[:, -new_data.shape[1]:] = new_data
+
+    def calculate_channel_contributions(self, features):
+        contributions = np.zeros(6)
+        for i in range(6):
+            channel_weights = self.model.layers[0].get_weights()[0][i * 6:(i + 1) * 6]
+            contributions[i] = np.mean(np.abs(channel_weights))
+        return contributions / np.sum(contributions)
+
+    def update_plot(self, frame):
+        new_data = self.get_next_chunk()
+        self.update_buffer(new_data)
+
+        features = self.extract_features(self.raw_buffer)
+        scaled_features = self.scaler.transform([features])
+        probs = self.model.predict(scaled_features, verbose=0)[0]
+
+        contributions = self.calculate_channel_contributions(features)
+
+        self.update_eeg_plot()
+        self.update_topomap()
+        self.update_contributions(contributions)
+        self.update_probabilities(probs)
+
+    def update_eeg_plot(self):
+        self.ax1.clear()
+        for i in range(6):
+            offset = i * 20e-6
+            self.ax1.plot(self.raw_buffer[i] + offset, label=self.ch_names[i])
+        self.ax1.legend(loc='upper right')
+
+    def update_topomap(self):
+        self.ax2.clear()
+        info = mne.create_info(self.ch_names, self.fs, 'eeg')
+        evoked = mne.EvokedArray(self.raw_buffer.mean(axis=1, keepdims=True), info)
+        evoked.set_montage(self.montage)
+        mne.viz.plot_topomap(evoked.data[:, 0], evoked.info, axes=self.ax2, show=False)
+
+    def update_contributions(self, contributions):
+        self.ax3.clear()
+        self.ax3.barh(self.ch_names, contributions, color='skyblue')
+        for i, v in enumerate(contributions):
+            self.ax3.text(v, i, f"{v * 100:.1f}%", color='black')
+
+    def update_probabilities(self, probs):
+        emotions = ['Mutlu / Happy', 'Kızgın / Angry', 'Üzgün / Sad', 'Sakin / Calm']
+        self.ax4.clear()
+        bars = self.ax4.barh(emotions, probs, color=['green', 'red', 'blue', 'purple'])
+        for bar in bars:
+            width = bar.get_width()
+            self.ax4.text(width, bar.get_y() + 0.2, f"{width * 100:.1f}%", ha='left')
+
+    def extract_features(self, data):
+        features = []
+        for channel in data:
+            features.extend([
+                np.mean(channel),
+                np.std(channel),
+                np.ptp(channel),
+                np.sum(np.abs(np.diff(channel))),
+                np.median(channel),
+                np.percentile(np.abs(channel), 95)
+            ])
+        return np.array(features)
+
+    def start_monitoring(self):
+        anim = FuncAnimation(self.fig, self.update_plot, interval=1000)
+        plt.show()
+
+
+if __name__ == "__main__":
+    monitor = EEGMonitor(
+        model_path="model/path/bai-6 Emotion.h5",
+        scaler_path="scaler/path/bai-6_scaler.save",
+        data_path="data/path/npy/or/csv"
+    )
+    monitor.start_monitoring()
+```
+-------------
+## Lisans/License
+CC-BY-NC-SA-4.0