Update README.md

README.md

@@ -40,161 +40,298 @@ tags:
 
 ### Direct Use
 
-<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+**Classical Use:**
 
-[More Information Needed]
+```python
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.models import load_model
+import matplotlib.pyplot as plt
 
-### Downstream Use [optional]
+model_path = 'model-path'
 
-<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+model = load_model(model_path)
 
-[More Information Needed]
+model_name = model_path.split('/')[-1].split('.')[0]
 
-### Out-of-Scope Use
+plt.figure(figsize=(10, 6))
+plt.title(f'Duygu Tahmini ({model_name})')
+plt.xlabel('Zaman')
+plt.ylabel('Sınıf')
+plt.legend(loc='upper right')
+plt.grid(True)
+plt.show()
+model.summary()
+```
 
-<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+**Prediction Test:**
 
-[More Information Needed]
+```python
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.models import load_model
 
-## Bias, Risks, and Limitations
+model_path = 'model-path'
 
-<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+model = load_model(model_path)
 
-[More Information Needed]
+scaler = StandardScaler()
 
-### Recommendations
+predictions = model.predict(X_new_reshaped)
+predicted_labels = np.argmax(predictions, axis=1)
 
-<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+label_mapping = {'NEGATIVE': 0, 'NEUTRAL': 1, 'POSITIVE': 2}
+label_mapping_reverse = {v: k for k, v in label_mapping.items()}
 
-Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+#new_input = np.array([[23, 465, 12, 9653] * 637])
+new_input = np.random.rand(1, 2548)  # 1 sample and 2548 features
+new_input_scaled = scaler.fit_transform(new_input)
+new_input_reshaped = new_input_scaled.reshape((new_input_scaled.shape[0], 1, new_input_scaled.shape[1]))
 
-## How to Get Started with the Model
+new_prediction = model.predict(new_input_reshaped)
+predicted_label = np.argmax(new_prediction, axis=1)[0]
+predicted_emotion = label_mapping_reverse[predicted_label]
 
-Use the code below to get started with the model.
+# TR Lang
+if predicted_emotion == 'NEGATIVE':
+    predicted_emotion = 'Negatif'
+elif predicted_emotion == 'NEUTRAL':
+    predicted_emotion = 'Nötr'
+elif predicted_emotion == 'POSITIVE':
+    predicted_emotion = 'Pozitif'
 
-[More Information Needed]
+print(f'Input Data: {new_input}')
+print(f'Predicted Emotion: {predicted_emotion}')
+```
 
-## Training Details
+**Realtime Use (EEG Monitoring without AI Model):**
 
-### Training Data
+```python
+import sys
+import pyaudio
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget
+from PyQt5.QtCore import QTimer
+from PyQt5.QtGui import QIcon
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
 
-<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
 
-[More Information Needed]
+CHUNK = 1000  # Chunk size
+FORMAT = pyaudio.paInt16  # Data type (16-bit PCM)
+CHANNELS = 1  # (Mono)
+RATE = 2000  # Sample rate (Hz)
 
-### Training Procedure
+p = pyaudio.PyAudio()
 
-<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+stream = p.open(format=FORMAT,
+                channels=CHANNELS,
+                rate=RATE,
+                input=True,
+                frames_per_buffer=CHUNK)
 
-#### Preprocessing [optional]
 
-[More Information Needed]
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
 
+        self.initUI()
 
-#### Training Hyperparameters
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.update_plot)
+        self.timer.start(1)
 
-- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+    def initUI(self):
+        self.setWindowTitle('EEG Monitoring by Neurazum')
+        self.setWindowIcon(QIcon('/neurazumicon.ico'))
 
-#### Speeds, Sizes, Times [optional]
+        self.central_widget = QWidget()
+        self.setCentralWidget(self.central_widget)
 
-<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+        self.layout = QVBoxLayout(self.central_widget)
 
-[More Information Needed]
+        self.fig, (self.ax1, self.ax2) = plt.subplots(2, 1, figsize=(12, 8), gridspec_kw={'height_ratios': [9, 1]})
+        self.fig.tight_layout()
+        self.canvas = FigureCanvas(self.fig)
 
-## Evaluation
+        self.layout.addWidget(self.canvas)
 
-<!-- This section describes the evaluation protocols and provides the results. -->
+        self.toolbar = NavigationToolbar(self.canvas, self)
+        self.layout.addWidget(self.toolbar)
 
-### Testing Data, Factors & Metrics
+        self.x = np.arange(0, 2 * CHUNK, 2)
+        self.line1, = self.ax1.plot(self.x, np.random.rand(CHUNK))
+        self.line2, = self.ax2.plot(self.x, np.random.rand(CHUNK))
 
-#### Testing Data
+        self.legend_elements = [
+            Line2D([0, 4], [0], color='yellow', lw=4, label='DELTA (0hz-4hz)'),
+            Line2D([4, 7], [0], color='blue', lw=4, label='THETA (4hz-7hz)'),
+            Line2D([8, 12], [0], color='green', lw=4, label='ALPHA (8hz-12hz)'),
+            Line2D([12, 30], [0], color='red', lw=4, label='BETA (12hz-30hz)'),
+            Line2D([30, 100], [0], color='purple', lw=4, label='GAMMA (30hz-100hz)')
+        ]
 
-<!-- This should link to a Dataset Card if possible. -->
+    def update_plot(self):
+        data = np.frombuffer(stream.read(CHUNK), dtype=np.int16)
+        data = np.abs(data)
+        voltage_data = data * (3.3 / 1024)  # Voltage to "mV"
 
-[More Information Needed]
+        self.line1.set_ydata(data)
+        self.line2.set_ydata(voltage_data)
 
-#### Factors
+        for coll in self.ax1.collections:
+            coll.remove()
 
-<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+        self.ax1.fill_between(self.x, data, where=((self.x >= 0) & (self.x <= 4)), color='yellow', alpha=1)
+        self.ax1.fill_between(self.x, data, where=((self.x >= 4) & (self.x <= 7)), color='blue', alpha=1)
+        self.ax1.fill_between(self.x, data, where=((self.x >= 8) & (self.x <= 12)), color='green', alpha=1)
+        self.ax1.fill_between(self.x, data, where=((self.x >= 12) & (self.x <= 30)), color='red', alpha=1)
+        self.ax1.fill_between(self.x, data, where=((self.x >= 30) & (self.x <= 100)), color='purple', alpha=1)
 
-[More Information Needed]
+        self.ax1.legend(handles=self.legend_elements, loc='upper right')
+        self.ax1.set_ylabel('Value (dB)')
+        self.ax1.set_xlabel('Frequency (Hz)')
+        self.ax1.set_title('Frequency and mV')
 
-#### Metrics
+        self.ax2.set_ylabel('Voltage (mV)')
+        self.ax2.set_xlabel('Time')
 
-<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+        self.canvas.draw()
 
-[More Information Needed]
+    def close_application(self):
+        self.timer.stop()
+        stream.stop_stream()
+        stream.close()
+        p.terminate()
+        sys.exit(app.exec_())
 
-### Results
 
-[More Information Needed]
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    mainWin = MainWindow()
+    mainWin.show()
+    sys.exit(app.exec_())
+```
 
-#### Summary
+**Emotion Dataset Prediction Use:**
 
+```python
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.models import load_model
 
+model_path = 'model-path'
+new_data_path = 'dataset-path'
 
-## Model Examination [optional]
+model = load_model(model_path)
 
-<!-- Relevant interpretability work for the model goes here -->
+new_data = pd.read_csv(new_data_path)
 
-[More Information Needed]
+X_new = new_data.drop('label', axis=1)
+y_new = new_data['label']
 
-## Environmental Impact
+scaler = StandardScaler()
+X_new_scaled = scaler.fit_transform(X_new)
+X_new_reshaped = X_new_scaled.reshape((X_new_scaled.shape[0], 1, X_new_scaled.shape[1]))
 
-<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+predictions = model.predict(X_new_reshaped)
+predicted_labels = np.argmax(predictions, axis=1)
 
-Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+label_mapping = {'NEGATIVE': 0, 'NEUTRAL': 1, 'POSITIVE': 2}
+label_mapping_reverse = {v: k for k, v in label_mapping.items()}
+actual_labels = y_new.replace(label_mapping).values
 
-- **Hardware Type:** [More Information Needed]
-- **Hours used:** [More Information Needed]
-- **Cloud Provider:** [More Information Needed]
-- **Compute Region:** [More Information Needed]
-- **Carbon Emitted:** [More Information Needed]
+accuracy = np.mean(predicted_labels == actual_labels)
 
-## Technical Specifications [optional]
+new_input = np.random.rand(2548, 2548)  # 1 sample and 2548 features
+new_input_scaled = scaler.transform(new_input)
+new_input_reshaped = new_input_scaled.reshape((new_input_scaled.shape[0], 1, new_input_scaled.shape[1]))
 
-### Model Architecture and Objective
+new_prediction = model.predict(new_input_reshaped)
+predicted_label = np.argmax(new_prediction, axis=1)[0]
+predicted_emotion = label_mapping_reverse[predicted_label]
 
-[More Information Needed]
 
-### Compute Infrastructure
+# TR Lang
+if predicted_emotion == 'NEGATIVE':
+    predicted_emotion = 'Negatif'
+elif predicted_emotion == 'NEUTRAL':
+    predicted_emotion = 'Nötr'
+elif predicted_emotion == 'POSITIVE':
+    predicted_emotion = 'Pozitif'
 
-[More Information Needed]
+print(f'Inputs: {new_input}')
+print(f'Predicted Emotion: {predicted_emotion}')
+print(f'Accuracy: %{accuracy * 100:.5f}')
+```
 
-#### Hardware
+## Bias, Risks, and Limitations
 
-[More Information Needed]
+**bai Models;**
 
-#### Software
+- _The biggest risk is wrong prediction :),_
+- _It does not contain any restrictions in any area (for now),_
+- _Data from brain signals do not contain personal information (because they are only mV values). Therefore, every guess made by bai is only a "GUESS"._
 
-[More Information Needed]
+### Recommendations
 
-## Citation [optional]
+- _Do not experience too many mood changes,_
+- _Do not take thoughts/decisions with too many different qualities,_
+- _When he/she makes a lot of mistakes, do not think that he/she gave the wrong answer (think of it as giving the correct answer),_
 
-<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+**Note: These items are only recommendations for better operation of the model. They do not carry any risk.**
 
-**BibTeX:**
+## How to Get Started with the Model
 
-[More Information Needed]
+- ```bash
+  pip install -r requirements.txt
+  ```
+- Place the path of the model in the example uses.
+- And run the file.
 
-**APA:**
+## Evaluation
 
-[More Information Needed]
+- bai-2.0 (Accuracy very high = 97%, 93621013133208)(EMOTIONAL CLASSIFICATION) (AUTONOMOUS MODEL) (High probability of OVERFITTING)
+- bai-2.1 (Accuracy very high = 97%, 93621013133208)(EMOTIONAL CLASSIFICATION) (AUTONOMOUS MODEL) (Low probability of OVERFITTING)
+- bai-2.2 (Accuracy very high = 94%, 8874296435272)(EMOTIONAL CLASSIFICATION) (AUTONOMOUS MODEL) (Low probability of OVERFITTING)
 
-## Glossary [optional]
+### Results
+
+[![image](https://r.resimlink.com/O7GyMoQL.png)](https://resimlink.com/O7GyMoQL)
+
+[![image](https://r.resimlink.com/gdyCW3RP.png)](https://resimlink.com/gdyCW3RP)
+
+[![image](https://r.resimlink.com/MpH9XS_0E.png)](https://resimlink.com/MpH9XS_0E)
+
+[![image](https://r.resimlink.com/vsyYqJnQ4k.png)](https://resimlink.com/vsyYqJnQ4k)
+
+#### Summary
+
+In summary, bai models continue to be developed to learn about and predict a person's thoughts and emotions.
+
+#### Hardware
+
+The EEG is the only hardware!
+
+#### Software
 
-<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+You can then operate this EEG device (for the time being only with audio input) with the real-time data monitoring application we have published.
 
-[More Information Needed]
+GitHub: https://github.com/neurazum/Realtime-EEG-Monitoring
 
-## More Information [optional]
+## More Information
 
-[More Information Needed]
+LinkedIn: https://www.linkedin.com/company/neurazum
 
 ## Model Card Authors [optional]
 
-[More Information Needed]
+Eyüp İpler - https://www.linkedin.com/in/eyupipler/
 
 ## Model Card Contact
 
-[More Information Needed]
+neurazum@gmail.com