NeruoTech platformunun tüm gücünü keşfedin. EEG işlemeden nöral ağ eğitimine, API entegrasyonundan ileri seviye optimizasyonlara kadar adım adım rehberlerle uzmanlaşın. Pratik örnekler, kod snippet'leri ve gerçek dünya senaryoları.
Sıfırdan başlayanlar için temel kavramlar ve adım adım öğrenme rehberleri.
10 dakikada NeruoTech'i kullanmaya başlayın. Hesap oluşturma, API anahtarı alma ve ilk isteğinizi gönderme adımları.
EEG cihazlarını bağlama, veri toplama ve temel ön işleme adımlarını öğrenin. Pratik örneklerle EEG sinyallerini anlayın.
Python'da NeruoTech SDK'sını kurun ve ilk API isteğinizi gönderin. Temel istemci oluşturma ve hata yönetimi.
EEG verilerini görselleştirin. Temel grafikler, spektral analiz ve zaman serisi görselleştirme teknikleri.
Farklı seviye ve ilgi alanlarına yönelik kapsamlı rehber kategorileri.
EEG veri toplama, ön işleme, analiz ve yorumlama için kapsamlı rehberler.
Derin öğrenme modelleri, eğitim teknikleri ve optimizasyon yöntemleri.
Çoklu dil desteği, best practice'ler ve gerçek dünya entegrasyon örnekleri.
İstatistiksel analiz, makine öğrenmesi ve veri görselleştirme teknikleri.
Modelleri production'a taşıma, scaling ve monitoring için kapsamlı rehberler.
Bilimsel araştırma tasarımı, etik kurallar ve yayın hazırlama rehberleri.
Derinlemesine teknik konular ve ileri seviye uygulamalar için hazırlanmış rehberler.
ICA, EEG sinyallerini istatistiksel olarak bağımsız bileşenlere ayırır:
import mne import numpy as np from mne.preprocessing import
ICA from mne.datasets import sample # Örnek veri yükleme
data_path = sample.data_path() raw_fname = data_path +
'/MEG/sample/sample_audvis_filt-0-40_raw.fif' raw =
mne.io.read_raw_fif(raw_fname, preload=True) # ICA uygulama
ica = ICA(n_components=20, random_state=97, max_iter=800)
ica.fit(raw) # Artefakt bileşenlerini tespit etme
ecg_indices, ecg_scores = ica.find_bads_ecg(raw,
method='correlation') eog_indices, eog_scores =
ica.find_bads_eog(raw) # Tespit edilen artefakt
bileşenlerini çıkarma ica.exclude = ecg_indices +
eog_indices ica.apply(raw) print(f"Çıkarılan bileşenler:
{ica.exclude}") print(f"Kalan bileşen sayısı:
{ica.n_components_ - len(ica.exclude)}")
Wavelet dönüşümü kullanarak non-stationary artefaktları temizleme:
import pywt import numpy as np def
wavelet_denoise(eeg_data, wavelet='db4', level=4,
threshold_method='soft'): """ Wavelet tabanlı gürültü
azaltma Parameters: ----------- eeg_data : numpy array EEG
verisi (channels x samples) wavelet : str Kullanılacak
wavelet tipi level : int Decomposition seviyesi
threshold_method : str 'soft' veya 'hard' thresholding
Returns: -------- denoised_data : numpy array Temizlenmiş
EEG verisi """ denoised_data = np.zeros_like(eeg_data) for
ch in range(eeg_data.shape[0]): # Wavelet decomposition
coeffs = pywt.wavedec(eeg_data[ch], wavelet, level=level) #
Threshold uygulama sigma = np.median(np.abs(coeffs[-1])) /
0.6745 threshold = sigma * np.sqrt(2 *
np.log(len(eeg_data[ch]))) # Her seviye için threshold
uygula coeffs_thresholded = [] for i, coeff in
enumerate(coeffs): if i > 0: # Approximation coefficient'e
dokunma if threshold_method == 'soft': coeff =
pywt.threshold(coeff, threshold, mode='soft') else: coeff =
pywt.threshold(coeff, threshold, mode='hard')
coeffs_thresholded.append(coeff) # Inverse wavelet transform
denoised_data[ch] = pywt.waverec(coeffs_thresholded,
wavelet) return denoised_data
CNN tabanlı derin öğrenme modeli ile artefakt tespiti:
import torch import torch.nn as nn import
torch.nn.functional as F class
ArtifactDetectorCNN(nn.Module): def __init__(self,
input_channels=32, seq_length=256):
super(ArtifactDetectorCNN, self).__init__() self.conv1 =
nn.Conv1d(input_channels, 64, kernel_size=5, padding=2)
self.bn1 = nn.BatchNorm1d(64) self.pool1 = nn.MaxPool1d(2)
self.conv2 = nn.Conv1d(64, 128, kernel_size=3, padding=1)
self.bn2 = nn.BatchNorm1d(128) self.pool2 = nn.MaxPool1d(2)
self.conv3 = nn.Conv1d(128, 256, kernel_size=3, padding=1)
self.bn3 = nn.BatchNorm1d(256) self.pool3 = nn.MaxPool1d(2)
# Global Average Pooling self.gap = nn.AdaptiveAvgPool1d(1)
self.fc1 = nn.Linear(256, 128) self.dropout =
nn.Dropout(0.5) self.fc2 = nn.Linear(128, 5) # 5 artefakt
tipi def forward(self, x): # x shape: (batch, channels,
seq_length) x = self.pool1(F.relu(self.bn1(self.conv1(x))))
x = self.pool2(F.relu(self.bn2(self.conv2(x)))) x =
self.pool3(F.relu(self.bn3(self.conv3(x)))) x =
self.gap(x).squeeze(-1) x = F.relu(self.fc1(x)) x =
self.dropout(x) x = self.fc2(x) return x # Model kullanımı
model = ArtifactDetectorCNN(input_channels=32,
seq_length=256) print(f"Model parametre sayısı:
{sum(p.numel() for p in model.parameters())}")
Temporal ve spatial attention mekanizmaları içeren özel transformer mimarisi:
import torch import torch.nn as nn import math class
EEGTransformer(nn.Module): def __init__(self,
num_channels=32, seq_length=256, num_classes=5, d_model=256,
nhead=8, num_layers=6, dim_feedforward=1024):
super(EEGTransformer, self).__init__() # Channel embedding
(spatial information) self.channel_embedding =
nn.Linear(num_channels, d_model) # Positional encoding
self.pos_encoder = PositionalEncoding(d_model, seq_length) #
Transformer encoder encoder_layer =
nn.TransformerEncoderLayer( d_model=d_model, nhead=nhead,
dim_feedforward=dim_feedforward, dropout=0.1,
activation='gelu' ) self.transformer_encoder =
nn.TransformerEncoder(encoder_layer, num_layers) #
Classification head self.classifier = nn.Sequential(
nn.Linear(d_model, 128), nn.GELU(), nn.Dropout(0.2),
nn.Linear(128, num_classes) ) # Initialize weights
self.init_weights() def init_weights(self): for p in
self.parameters(): if p.dim() > 1:
nn.init.xavier_uniform_(p) def forward(self, x): # x shape:
(batch, channels, seq_length) batch_size = x.shape[0] #
Channel dimension'ı sona al x = x.transpose(1, 2) # (batch,
seq_length, channels) # Channel embedding x =
self.channel_embedding(x) # (batch, seq_length, d_model) #
Positional encoding ekle x = self.pos_encoder(x) #
Transformer için dimension rearrangement x = x.transpose(0,
1) # (seq_length, batch, d_model) # Transformer encoder x =
self.transformer_encoder(x) # Global average pooling x =
x.mean(dim=0) # (batch, d_model) # Classification output =
self.classifier(x) return output class
PositionalEncoding(nn.Module): def __init__(self, d_model,
max_len=5000): super(PositionalEncoding, self).__init__() pe
= torch.zeros(max_len, d_model) position = torch.arange(0,
max_len, dtype=torch.float).unsqueeze(1) div_term =
torch.exp(torch.arange(0, d_model, 2).float() *
(-math.log(10000.0) / d_model)) pe[:, 0::2] =
torch.sin(position * div_term) pe[:, 1::2] =
torch.cos(position * div_term) pe =
pe.unsqueeze(0).transpose(0, 1) self.register_buffer('pe',
pe) def forward(self, x): # x shape: (batch, seq_length,
d_model) x = x + self.pe[:x.size(1), :].transpose(0, 1)
return x
Attention heatmap'lerini görselleştirme:
import numpy as np import matplotlib.pyplot as plt import
seaborn as sns def visualize_attention(attention_weights,
channel_names, save_path=None): """ Multi-head attention
weights'lerini görselleştirme Parameters: -----------
attention_weights : numpy array Attention weights (n_heads,
seq_length, seq_length) channel_names : list Kanal isimleri
listesi save_path : str Görsel kaydetme yolu (opsiyonel) """
n_heads = attention_weights.shape[0] fig, axes =
plt.subplots(2, 4, figsize=(20, 10)) axes = axes.flatten()
for i in range(min(n_heads, 8)): ax = axes[i]
sns.heatmap(attention_weights[i], ax=ax, cmap='viridis',
cbar=True, square=True, xticklabels=channel_names if i == 0
else False, yticklabels=channel_names if i == 0 else False)
ax.set_title(f'Head {i+1}') ax.set_xlabel('Keys')
ax.set_ylabel('Queries') plt.tight_layout() if save_path:
plt.savefig(save_path, dpi=300, bbox_inches='tight')
plt.show() # Örnek kullanım # attention_weights =
model.get_attention_weights(eeg_sample) # channel_names =
['Fp1', 'Fp2', 'F3', 'F4', 'C3', 'C4', 'P3', 'P4', 'O1',
'O2'] # visualize_attention(attention_weights,
channel_names)
Temporal ve spatial bilgiyi birleştiren hybrid attention mekanizması:
class TemporalSpatialAttention(nn.Module): def
__init__(self, d_model, num_channels, num_heads=8,
dropout=0.1): super(TemporalSpatialAttention,
self).__init__() # Temporal attention (zaman boyutu)
self.temporal_attention = nn.MultiheadAttention(
embed_dim=d_model, num_heads=num_heads, dropout=dropout,
batch_first=True ) # Spatial attention (kanal boyutu)
self.spatial_attention = nn.MultiheadAttention(
embed_dim=d_model, num_heads=num_heads, dropout=dropout,
batch_first=True ) # Cross-attention self.cross_attention =
nn.MultiheadAttention( embed_dim=d_model,
num_heads=num_heads, dropout=dropout, batch_first=True ) #
Layer normalization self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model) self.norm3 =
nn.LayerNorm(d_model) # Feed-forward network self.ffn =
nn.Sequential( nn.Linear(d_model, d_model * 4), nn.GELU(),
nn.Dropout(dropout), nn.Linear(d_model * 4, d_model) )
self.dropout = nn.Dropout(dropout) def forward(self,
temporal_features, spatial_features): # Temporal attention
temporal_attn, _ = self.temporal_attention(
temporal_features, temporal_features, temporal_features )
temporal_features = self.norm1(temporal_features +
self.dropout(temporal_attn)) # Spatial attention
spatial_attn, _ = self.spatial_attention( spatial_features,
spatial_features, spatial_features ) spatial_features =
self.norm2(spatial_features + self.dropout(spatial_attn)) #
Cross attention (temporal -> spatial) cross_attn, _ =
self.cross_attention( spatial_features, temporal_features,
temporal_features ) fused_features =
self.norm3(spatial_features + self.dropout(cross_attn)) #
Feed-forward fused_features = fused_features +
self.dropout(self.ffn(fused_features)) return
fused_features
Kariyer hedeflerinize ve ilgi alanlarınıza göre önerilen öğrenme yolları ve rehber serileri.
Görsel öğrenme için hazırlanmış kapsamlı video eğitim serileri.
24 Video • 18 Saat
EEG cihaz kurulumu, veri toplama, temel analiz ve yorumlama.
Pratik laboratuvar uygulamaları ile desteklenmiştir.
36 Video • 32 Saat
NumPy, Pandas, Matplotlib, Scikit-learn kütüphaneleri ile veri
analizi ve makine öğrenmesi uygulamaları.
42 Video • 45 Saat
PyTorch ile derin öğrenme modelleri, transformer mimarileri ve
gerçek dünya uygulamaları.
18 Video • 20 Saat
AWS, GCP, Azure üzerinde model deployment, scaling ve monitoring
uygulamaları.
Alanında uzman isimler tarafından hazırlanan ileri seviye rehberler ve interaktif workshop'lar.
Stanford Üniversitesi'nde nörobilim profesörü. EEG ve fMRI veri füzyonu, çok modalite nörogörüntüleme teknikleri.
MIT'de yapay zeka araştırmacısı. Transformer modelleri, attention mekanizmaları ve explainable AI.
Tokyo Üniversitesi'nde klinik nöroloji uzmanı. Epilepsi tespiti, sleep staging, klinik EEG yorumlama.
Sizin için özelleştirilmiş öğrenme yolunu keşfedin. İster başlangıç seviyesinde olun, ister uzmanlaşmak isteyin, size uygun rehberler ve eğitimlerle destek sağlıyoruz.