Natuurlijk! Hier is een overzicht van de essentiële stappen en voorbeeldcode om een PyTorch-model te maken voor anomaliedetectie op jouw dataset met 1000 tijdreeksgegevens en 5 functies. ### 1. Gegevensvoorbereiding - **Normaliseren**: Schaal de gegevens bijvoorbeeld met `MinMaxScaler` of `StandardScaler`. - **Sequenties vormen**: Voor tijdreeksen moet je mogelijk sequenties maken (bijvoorbeeld vensteren van bepaalde lengte). - **Train/test splitsen**: Zorg dat je vooral de normale data gebruikt voor training, omdat anomalieën zelden voorkomen. ```python import numpy as np from sklearn.preprocessing import StandardScaler # Stel dat data.shape = (1000, 5) data = ... # jouw dataset # Normaliseer de data scaler = StandardScaler() data_scaled = scaler.fit_transform(data) # Sequenties maken (bijvoorbeeld vensterlengte 20) sequence_length = 20 sequences = [] for i in range(len(data_scaled) - sequence_length): sequences.append(data_scaled[i:i+sequence_length]) sequences = np.array(sequences) # shape: (n_samples, seq_len, features) ``` ### 2. Modelselectie Voor anomaliedetectie is een auto-encoder vaak geschikt, vooral voor ongesuperviseerde aanpak: - **Auto-encoder**: leert een compacte representatie en reconstructie van normale gegevens. - Bij afwijkingen zal de reconstructiefout groot zijn. ### 3. Modelarchitectuur (Auto-encoder met LSTM) ```python import torch import torch.nn as nn class LSTM_Autoencoder(nn.Module): def __init__(self, input_dim, hidden_dim, latent_dim, num_layers=1): super(LSTM_Autoencoder, self).__init__() self.encoder = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True) self.latent = nn.Linear(hidden_dim, latent_dim) self.decoder_input = nn.Linear(latent_dim, hidden_dim) self.decoder = nn.LSTM(hidden_dim, input_dim, num_layers, batch_first=True) def forward(self, x): # Encoder out, (h_n, c_n) = self.encoder(x) # Laatste output voor bottleneck h = out[:, -1, :] # (batch, hidden_dim) z = self.latent(h) # Decoder dec_input = self.decoder_input(z).unsqueeze(1).repeat(1, x.size(1), 1) dec_out, _ = self.decoder(dec_input) return dec_out ``` ### 4. Trainingsstrategieën - **Lossfunctie**: MSE tussen invoer en reconstructie. - **Train vooral op normale data**. - **Drempelwaarde bepalen**: na training, bereken de reconstructiefout op validatie/data, en bepaal een drempel (bijvoorbeeld 95e percentiel) voor anomalie. ```python import torch.optim as optim model = LSTM_Autoencoder(input_dim=5, hidden_dim=32, latent_dim=16) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) num_epochs = 50 batch_size = 32 # Omzetten naar torch tensors dataset = torch.tensor(sequences, dtype=torch.float32) for epoch in range(num_epochs): permutation = torch.randperm(dataset.size(0)) for i in range(0, dataset.size(0), batch_size): indices = permutation[i:i+batch_size] batch = dataset[indices] optimizer.zero_grad() output = model(batch) loss = criterion(output, batch) loss.backward() optimizer.step() print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}") ``` ### 5. Anomaliedetectie - Na training, bereken reconstructiefouten op nieuwe data. - Stel een drempel in op basis van de foutverdeling. ```python # Voor nieuw data model.eval() with torch.no_grad(): reconstructions = model(dataset) errors = torch.mean((reconstructions - dataset)**2, dim=(1,2)) # Drempel bepalen threshold = np.percentile(errors.numpy(), 95) # Anomalieën identificeren anomalies = errors > threshold ``` --- ### Samenvatting - **Datavoorbereiding**: normaliseren, sequenties maken. - **Model**: Auto-encoder met LSTM. - **Training**: train op normale data, gebruik MSE verlies. - **Detectie**: gebruik reconstructiefout en stel een drempel in. Wil je verder in detail, bijvoorbeeld over hyperparameterafstemming of meer geavanceerde technieken?

Zeker, ik begeleid je stap voor stap bij het maken van een PyTorch-model voor anomaliedetectie op tijdreeksgegevens. Hier is een complete handleiding met codevoorbeelden: ### 1. Gegevensvoorbereiding ```python import torch import numpy as np from sklearn.preprocessing import StandardScaler from torch.utils.data import DataLoader, TensorDataset # Laad je dataset (voorbeeld) # data.shape = (1000, 5) - 1000 tijdstappen, 5 features data = np.loadtxt('jouw_data.csv', delimiter=',') # Normaliseer de gegevens scaler = StandardScaler() normalized_data = scaler.fit_transform(data) # Maak sliding windows voor tijdreeksanalyse def create_sequences(data, seq_length): sequences = [] for i in range(len(data) - seq_length): sequences.append(data[i:i + seq_length]) return np.array(sequences) seq_length = 30 # Aanpasbaar sequences = create_sequences(normalized_data, seq_length) # Converteer naar PyTorch tensors tensor_sequences = torch.FloatTensor(sequences) dataset = TensorDataset(tensor_sequences, tensor_sequences) # Auto-encoder doelen dataloader = DataLoader(dataset, batch_size=32, shuffle=True) ``` ### 2. Modelarchitectuur - LSTM Auto-Encoder ```python import torch.nn as nn class LSTMAutoencoder(nn.Module): def __init__(self, input_dim, hidden_dim, num_layers=2): super().__init__() self.encoder = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True) self.decoder = nn.LSTM(hidden_dim, hidden_dim, num_layers, batch_first=True) self.output_layer = nn.Linear(hidden_dim, input_dim) def forward(self, x): # Encoder _, (hidden, cell) = self.encoder(x) # Decoder (gebruik laatste verborgen toestand) decoder_input = torch.zeros(x.size(0), x.size(1), hidden.size(2)).to(x.device) decoded, _ = self.decoder(decoder_input, (hidden, cell)) output = self.output_layer(decoded) return output # Model initialisatie model = LSTMAutoencoder(input_dim=5, hidden_dim=10) print(model) ``` ### 3. Trainingsstrategie ```python # Training setup criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5) # Training loop def train_model(model, dataloader, epochs): model.train() for epoch in range(epochs): total_loss = 0 for batch in dataloader: inputs = batch[0] optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, inputs) # Reconstruction loss loss.backward() optimizer.step() total_loss += loss.item() if epoch % 50 == 0: print(f'Epoch {epoch}, Loss: {total_loss/len(dataloader):.6f}') # Train het model train_model(model, dataloader, epochs=200) ``` ### 4. Anomaliedetectie ```python def detect_anomalies(model, data, threshold_std=3): model.eval() with torch.no_grad(): reconstructions = model(data) reconstruction_errors = torch.mean((data - reconstructions)**2, dim=(1,2)) # Bepaal drempelwaarde op basis van fouten error_mean = reconstruction_errors.mean() error_std = reconstruction_errors.std() threshold = error_mean + threshold_std * error_std anomalies = reconstruction_errors > threshold return anomalies.numpy(), reconstruction_errors.numpy() # Gebruik voor detectie anomalies, errors = detect_anomalies(model, tensor_sequences) print(f"Aantal gedetecteerde anomalieën: {np.sum(anomalies)}") ``` ### 5. Alternatieve Architectuur - Eenvoudige Auto-Encoder ```python class SimpleAutoencoder(nn.Module): def __init__(self, input_dim, encoding_dim): super().__init__() self.encoder = nn.Sequential( nn.Linear(input_dim, encoding_dim), nn.ReLU(), ) self.decoder = nn.Sequential( nn.Linear(encoding_dim, input_dim), nn.Sigmoid() # Optioneel, afhankelijk van je data ) def forward(self, x): encoded = self.encoder(x) decoded = self.decoder(encoded) return decoded # Voor tijdreeksen: flatten de sequentie simple_ae = SimpleAutoencoder(input_dim=5*seq_length, encoding_dim=20) ``` ### Belangrijke Tips: 1. **Validatie**: Houd een validatieset apart voor hyperparameter tuning 2. **Drempelbepaling**: Gebruik percentielen (bijv. 95e percentiel) in plaats van standaarddeviatie 3. **Vroege stop**: Implementeer early stopping om overfitting te voorkomen 4. **Verschillende architecturen**: - Voor periodieke patronen: LSTM - Voor statische patronen: Dense Auto-Encoder - Voor complexe patronen: Variational Auto-Encoders (VAE) ### Evaluatie: ```python from sklearn.metrics import precision_recall_fscore_support # Als je gelabelde anomalieën hebt voor evaluatie # y_true = echte labels precision, recall, f1, _ = precision_recall_fscore_support(y_true, anomalies, average='binary') print(f"Precisie: {precision:.3f}, Recall: {recall:.3f}, F1: {f1:.3f}") ``` Dit framework geeft je een solide basis voor anomaliedetectie op je tijdreeksdata. Pas de parameters aan op basis van je specifieke dataset en vereisten!