可以给我相关的代码吗

当然可以，这里给你提供一个基本的代码架构，你可以根据需要进行修改和优化。这个代码包括了数据集的预处理、模型的训练和评估、分类结果的保存等主要步骤，你可以根据需要进行补充和修改。

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim
import os
import numpy as np
from sklearn.metrics import confusion_matrix
from tqdm import tqdm

# 定义数据集路径和标签
data_dir = "D:/wjd"  # 数据集路径
labels = ['Ag', 'Al', 'Au', 'Cu', 'W', 'V', 'Mo', 'Ta']  # 标签

# 定义数据预处理
transform_train = transforms.Compose([
    transforms.RandomCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

transform_val = transforms.Compose([
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# 定义数据集
train_data = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'), transform=transform_train)
val_data = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'val'), transform=transform_val)

# 定义数据加载器
train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True, num_workers=4)
val_loader = torch.utils.data.DataLoader(val_data, batch_size=32, shuffle=False, num_workers=4)

# 定义模型
model = torchvision.models.resnet50(pretrained=True)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, len(labels))

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 定义训练函数
def train(model, dataloader, criterion, optimizer):
    model.train()
    running_loss = 0.0
    running_corrects = 0

    for inputs, labels in tqdm(dataloader):
        inputs = inputs.cuda()
        labels = labels.cuda()

        optimizer.zero_grad()
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item() * inputs.size(0)
        running_corrects += torch.sum(preds == labels.data)

    epoch_loss = running_loss / len(dataloader.dataset)
    epoch_acc = running_corrects.double() / len(dataloader.dataset)

    return epoch_loss, epoch_acc

# 定义评估函数
def evaluate(model, dataloader, criterion):
    model.eval()
    running_loss = 0.0
    running_corrects = 0

    y_true = []
    y_pred = []

    with torch.no_grad():
        for inputs, labels in tqdm(dataloader):
            inputs = inputs.cuda()
            labels = labels.cuda()

            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)
            loss = criterion(outputs, labels)

            running_loss += loss.item() * inputs.size(0)
            running_corrects += torch.sum(preds == labels.data)

            y_true.extend(labels.cpu().numpy())
            y_pred.extend(preds.cpu().numpy())

    epoch_loss = running_loss / len(dataloader.dataset)
    epoch_acc = running_corrects.double() / len(dataloader.dataset)

    return epoch_loss, epoch_acc, y_true, y_pred

# 定义主函数
def main():
    # 训练模型
    for epoch in range(10):
        train_loss, train_acc = train(model, train_loader, criterion, optimizer)
        val_loss, val_acc, val_y_true, val_y_pred = evaluate(model, val_loader, criterion)
        
        print('Epoch: {:02d}, Train Loss: {:.4f}, Train Acc: {:.4f}, Val Loss: {:.4f}, Val Acc: {:.4f}'.format(
            epoch+1, train_loss, train_acc, val_loss, val_acc))

    # 评估模型
    _, _, val_y_true, val_y_pred = evaluate(model, val_loader, criterion)
    val_cm = confusion_matrix(val_y_true, val_y_pred)
    print('Confusion Matrix:', val_cm)

    # 保存分类结果
    test_dir = "D:/test"  # 测试集路径
    test_data = torchvision.datasets.ImageFolder(test_dir, transform=transform_val)
    test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, shuffle=False, num_workers=4)

    model.eval()
    with torch.no_grad():
        for inputs, _ in test_loader:
            inputs = inputs.cuda()
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)

            for i in range(inputs.shape[0]):
                img_path = test_data.imgs[i][0]
                img_name = os.path.basename(img_path)
                label_name = labels[preds[i]]
                save_dir = "D:/jk/" + label_name

                if not os.path.exists(save_dir):
                    os.makedirs(save_dir)

                save_path = os.path.join(save_dir, img_name)
                os.rename(img_path, save_path)

if __name__ == '__main__':
    main()

这个代码可能还需要一些修改和优化，比如你可能需要调整模型的超参数、修改数据预处理的方法、增加数据增强的方式、调整训练和评估的指标等。但是，这个代码已经提供了一个完整的框架，可以帮助你开始实现这个任务。