import torch import torch.nn as nn import torch.optim as optim import numpy as np from torch.autograd import Variable

Define the model architecture

class ConvNet(nn.Module): def init(self): super(ConvNet, self).init() self.conv1 = nn.Conv2d(1, 32, kernel_size=3) self.pool = nn.MaxPool2d(2, 2) self.dropout = nn.Dropout2d(p=0.5) self.fc1 = nn.Linear(32 * 23 * 23, 128) self.fc2 = nn.Linear(128, 8)

def forward(self, x):
    x = self.conv1(x)
    x = self.pool(x)
    x = self.dropout(x)
    x = x.view(x.size(0), -1)
    x = self.fc1(x)
    x = self.fc2(x)
    return x

Define the training function

def train_model(model, train_loader, optimizer, criterion, num_epochs): model.train() for epoch in range(num_epochs): running_loss = 0.0 for batch_idx, (inputs, targets) in enumerate(train_loader): inputs, targets = Variable(inputs), Variable(targets) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() running_loss += loss.item() print('Epoch [%d/%d], Loss: %.4f' % (epoch+1, num_epochs, running_loss))

Prepare the data

train_data = np.genfromtxt('train_data.txt', delimiter=',') train_X = train_data[:, :23].reshape(-1, 1, 23, 1) train_Y = train_data[:, 23].astype(int)

Normalize the data

train_X = (train_X - np.mean(train_X)) / np.std(train_X)

Convert numpy arrays to torch tensors

train_X = torch.from_numpy(train_X).float() train_Y = torch.from_numpy(train_Y).long()

Create a data loader

train_dataset = torch.utils.data.TensorDataset(train_X, train_Y) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True)

Create the model, optimizer, and loss function

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

Train the model

train_model(model, train_loader, optimizer, criterion, num_epochs=10)