Now train a OneFCNet using your Gradient Descent optimizer, the data loader which iterates over all samples in one batch with a Cross Entropy loss (hint: there is an implementation of PyTorch for this loss). For testing the optimizers we are not yet interested in the validation loss. So no need to provide a validation loader. 帮我按照上面的要求补充下面的代码 net = ... epochs = 10 optimizer = GD(net.parameters(), 0.002) loss_fn = ... losses, states = ... fig = plot_losses(losses) iplot(fig)

Sure, here's the code snippet that satisfies your requirements:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from tqdm import tqdm
import matplotlib.pyplot as plt
from IPython.display import display, clear_output

# Define your OneFCNet model
class OneFCNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(100, 10)
    
    def forward(self, x):
        x = self.fc(x)
        return x

# Define your Gradient Descent optimizer
class GD():
    def __init__(self, params, lr):
        self.params = list(params)
        self.lr = lr
        
    def step(self):
        with torch.no_grad():
            for p in self.params:
                p -= self.lr * p.grad
                p.grad.zero_()

# Define your training function
def train(net, loader, optimizer, loss_fn):
    net.train()
    losses = []
    states = []
    for epoch in range(epochs):
        running_loss = 0.0
        for i, data in tqdm(enumerate(loader)):
            inputs, labels = data
            optimizer.zero_grad()
            outputs = net(inputs)
            loss = loss_fn(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()

        epoch_loss = running_loss / len(loader)
        losses.append(epoch_loss)
        states.append([p.detach().clone() for p in net.parameters()])

        clear_output(wait=True)
        fig = plot_losses(losses)
        display(fig)

    return losses, states

# Define your data loader
class MyDataset(torch.utils.data.Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels
        
    def __getitem__(self, index):
        x = self.data[index]
        y = self.labels[index]
        return x, y
    
    def __len__(self):
        return len(self.data)

# Create your OneFCNet object
net = OneFCNet()

# Define number of epochs, learning rate, Gradient Descent optimizer, and Cross Entropy loss
epochs = 10
lr = 0.002
optimizer = GD(net.parameters(), lr)
loss_fn = nn.CrossEntropyLoss()

# Create your data and labels tensors
data = torch.randn(1000, 100)
labels = torch.randint(0, 10, (1000,))

# Create your data loader
dataset = MyDataset(data, labels)
loader = DataLoader(dataset, batch_size=32, shuffle=True)

# Call your train function to train the model
losses, states = train(net, loader, optimizer, loss_fn)

Note that I assumed that you already have a `plot_losses` function that plots the training loss over time. If you don't have one already, you can define it as follows:

def plot_losses(losses):
    fig, ax = plt.subplots(figsize=(8, 6))
    ax.plot(losses)
    ax.set_xlabel('Epochs')
    ax.set_ylabel('Loss')
    ax.set_title('Training Loss')
    plt.show()
    return fig