import torch import torch.nn as nn import torch.optim as optim

Define the GRU model

class GRUModel(nn.Module): def init(self, input_size, hidden_size, output_size): super(GRUModel, self).init() self.hidden_size = hidden_size self.gru = nn.GRU(input_size, hidden_size) self.fc = nn.Linear(hidden_size, output_size)

def forward(self, input):
    hidden = self.init_hidden()
    output, _ = self.gru(input, hidden)
    output = self.fc(output[-1])
    return output

def init_hidden(self):
    return torch.zeros(1, 1, self.hidden_size)

Preprocess the data

def preprocess_data(data_file): with open(data_file, 'r') as f: lines = f.readlines() data = [] labels = [] for line in lines: line = line.strip().split(',') data.append(list(map(float, line[:-1]))) labels.append(int(line[-1])) return data, labels

Convert data to tensors

def convert_to_tensors(data, labels): data_tensor = torch.tensor(data, dtype=torch.float32) labels_tensor = torch.tensor(labels, dtype=torch.long) return data_tensor, labels_tensor

Define hyperparameters

input_size = 24 hidden_size = 16 output_size = 8 learning_rate = 0.001 num_epochs = 100

Load and preprocess the data

data, labels = preprocess_data('data.txt') data_tensor, labels_tensor = convert_to_tensors(data, labels)

Split the data into training and testing sets

train_size = int(0.8 * len(data)) train_data = data_tensor[:train_size] train_labels = labels_tensor[:train_size] test_data = data_tensor[train_size:] test_labels = labels_tensor[train_size:]

Initialize the GRU model

model = GRUModel(input_size, hidden_size, output_size)

Define the loss function and optimizer

criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate)

Train the model

for epoch in range(num_epochs): model.train() optimizer.zero_grad() output = model(train_data) loss = criterion(output, train_labels) loss.backward() optimizer.step()

# Print the loss every 10 epochs
if (epoch+1) % 10 == 0:
    print(f'Epoch: {epoch+1}, Loss: {loss.item()}')

Test the model

model.eval() with torch.no_grad(): output = model(test_data) predicted_labels = torch.argmax(output, dim=1) accuracy = (predicted_labels == test_labels).sum().item() / len(test_labels) print(f'Accuracy: {accuracy}'