用p写一段基于深度卷积神经网络和迁移学习的纹理图像识别的代码

好的，以下是一个基于深度卷积神经网络和迁移学习的纹理图像识别的代码示例，使用Python编写，并使用PyTorch深度学习框架：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
import torchvision.transforms as transforms
import torchvision.datasets as datasets

# 设置GPU设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 定义网络模型
class TextureClassifier(nn.Module):
    def __init__(self, num_classes):
        super(TextureClassifier, self).__init__()
        self.model = models.vgg16(pretrained=True)
        self.model.classifier = nn.Sequential(
            nn.Linear(25088, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes)
        )
        
    def forward(self, x):
        x = self.model(x)
        return x

# 加载数据集
data_dir = "/path/to/texture/dataset"
train_dataset = datasets.ImageFolder(
    data_dir + '/train',
    transforms.Compose([
        transforms.Resize(256),
        transforms.RandomCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
)
val_dataset = datasets.ImageFolder(
    data_dir + '/val',
    transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
)

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

# 定义损失函数和优化器
model = TextureClassifier(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 训练模型
for epoch in range(10):
    model.train()
    for i, (inputs, labels) in enumerate(train_loader):
        inputs = inputs.to(device)
        labels = labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

    # 在验证集上测试模型
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            inputs = inputs.to(device)
            labels = labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    # 输出每个epoch的准确率
    print('Epoch: {}, Accuracy: {:.2f}%'.format(epoch+1, 100 * correct / total))

在上面的代码中，我们使用了预训练的VGG-16模型作为基础模型，并在其基础上构建了我们自己的分类器。我们使用了ImageFolder数据集来加载我们的纹理数据集，并使用了一系列数据增强技术来增加数据的多样性。我们还定义了损失函数和优化器，并在每个epoch中训练模型以最小化损失函数。最后，在每个epoch中，我们在验证集上测试模型，并输出准确率。