Neurales Netzwerkmodell im Pytorch -Vorhersageproblem für die Erkennung von Anomalie in einem simulierten Bewässerungssy ⇐ Python

[Anonymous]

Ich arbeite an meinem endgültigen Studienprojekt, bei dem Anomalien in einem Bewässerungssystem nachgewiesen werden. Meine Idee ist es, es einfach zu machen und ein einfaches Modell für neuronales Netzwerk mit Pytorch zu erstellen, das den Zustand der Ventile als Eingabe erhält (0 ist aus und 1 auf Ex: 0110) und eine Ausgabe, was der Druckwert ist. Das bedeutet also, dass unser System Druck aus den Ventilkombinationen vorhersagt. Der Datensatz wird erstellt, indem bestimmte Ventilkombinationen (mithilfe von fraktionalem faktorielles Design) abgerufen werden, aber ich habe andere Kombinationen wie 1000, 0100, 0010, 00001, 1110 und 0111 hinzugefügt. Dann wird er erweitert, um einen großen Datensatz zu erhalten.
Hier ist das Modell: < /p>
import torch
import torch.nn as nn

class PressureNeuralNet(nn.Module):
def __init__(self, n_valves, hidden_size=32, dropout_rate=0.1):
super().__init__()
self.network = nn.Sequential(
nn.Linear(n_valves, hidden_size),
nn.ReLU(),
nn.Dropout(dropout_rate),

nn.Linear(hidden_size, hidden_size),
nn.ReLU(),
nn.Linear(hidden_size, 1)
)

def forward(self, x):
return self.network(x)
< /code>
Lernprozess: < /p>
nn_model = PressureNeuralNet(n_valves)

# Define loss and optimizers
criterion = nn.MSELoss()
nn_optimizer = optim.Adam(nn_model.parameters(), lr=0.01, weight_decay=1e-5)
nn_scheduler = optim.lr_scheduler.ReduceLROnPlateau(nn_optimizer, mode='min', patience=5, factor=0.5, verbose=True)

print("\nTraining Neural Network...")
nn_train_losses, nn_test_losses = train_model(
nn_model, train_loader, test_loader, criterion, nn_optimizer, nn_scheduler
)
< /code>
Zugmodellfunktion: < /p>
def train_model(model, train_loader, test_loader, criterion, optimizer, scheduler=None, epochs=1000):
train_losses = []
test_losses = []
best_test_loss = float('inf')

for epoch in range(epochs):
model.train()
running_loss = 0.0
for valve_states, pressures in train_loader:
optimizer.zero_grad()
outputs = model(valve_states).squeeze()
loss = criterion(outputs, pressures)
loss.backward()
optimizer.step()
running_loss += loss.item()

avg_train_loss = running_loss / len(train_loader)
train_losses.append(avg_train_loss)

model.eval()
test_loss = 0.0
with torch.no_grad():
for valve_states, pressures in test_loader:
outputs = model(valve_states).squeeze()
loss = criterion(outputs, pressures)
test_loss += loss.item()

avg_test_loss = test_loss / len(test_loader)
test_losses.append(avg_test_loss)

if avg_test_loss < best_test_loss:
best_test_loss = avg_test_loss
torch.save(model.state_dict(), 'best_model.pth')
print(f"Saved best model with Test Loss: {best_test_loss:.4f}")

if scheduler:
scheduler.step(avg_test_loss)

if (epoch + 1) % 10 == 0:
print(f"Epoch [{epoch + 1}/{epochs}], Train Loss: {avg_train_loss:.4f}, Test Loss: {avg_test_loss:.4f}")
if scheduler:
print(f"Current Learning Rate: {optimizer.param_groups[0]['lr']:.6f}")

return train_losses, test_losses
< /code>
Der MSE -Wert lautet: 0,0004
, dass das Modell sehr gut vorhersagt. Das Problem ist nun, dass bei der Vorhersage einer Kombination, die aus dem Datensatz nicht gelernt wurde (1101 Lesewert: 0,53 vorhergesagt: 0,10, was eine falsche Warnung ist). Aufgrund der Stichprobenmethode, die wir verwendet haben (fraktionelles faktorielles Design). Seien Sie ein Problem, da die Werte der einzelnen Ventile Kombinationen alle den gleichen Wert haben: 0,5, aber die Kombination 0100 hat einen Druckwert: 0,45. Ich habe meine Frage nicht sehr gut gestellt.