基于pytorch的121数据集转化为1111灰度图像在用dcgan 生成之后cnn分类代码

将1x121的数据集转化为11x11的灰度图像，可以按照如下步骤进行：

1. 将1x121的数据集reshape为1x11x11的三维数据。
2. 将三维数据转化为灰度图像，可以使用PIL、OpenCV等图像处理库来实现。

对于使用DCGAN生成图像，可以参考上面的回答。

生成图像后，可以使用CNN分类器来对图像进行分类。具体的代码实现步骤如下：

1. 加载生成的图像数据，获取图像数据和标签数据。
2. 对图像数据进行预处理，包括将像素值归一化、将图像转化为灰度图像等。
3. 构建CNN分类器模型，包括卷积层、池化层、全连接层等。
4. 使用训练集训练CNN模型，得到训练好的模型参数。
5. 使用测试集对CNN模型进行测试，计算模型的分类准确率。

下面是一个简单的PyTorch实现代码，供参考：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import transforms
from PIL import Image

# 定义数据集类
class MyDataset(Dataset):
    def __init__(self, images, labels, transform=None):
        self.images = images
        self.labels = labels
        self.transform = transform
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        image = self.images[idx]
        label = self.labels[idx]
        if self.transform:
            image = self.transform(image)
        return image, label

# 加载生成的图像数据和标签数据
images = np.load('generated_images.npy')
labels = np.load('generated_labels.npy')

# 对图像数据进行预处理
transform = transforms.Compose([
    transforms.ToPILImage(),
    transforms.Grayscale(),
    transforms.Resize((11, 11)),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
dataset = MyDataset(images, labels, transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 构建CNN分类器模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.conv3 = nn.Conv2d(64, 64, 3)
        self.fc1 = nn.Linear(64 * 2 * 2, 64)
        self.fc2 = nn.Linear(64, 10)
    
    def forward(self, x):
        x = self.pool1(nn.functional.relu(self.conv1(x)))
        x = self.pool2(nn.functional.relu(self.conv2(x)))
        x = nn.functional.relu(self.conv3(x))
        x = x.view(-1, 64 * 2 * 2)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 训练CNN模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(dataloader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

# 在测试集上测试CNN模型
test_images, test_labels = images[8000:], labels[8000:]
test_dataset = MyDataset(test_images, test_labels, transform)
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)
correct = 0
total = 0
with torch.no_grad():
    for data in test_dataloader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy: %d %%' % (100 * correct / total))

需要注意的是，CNN模型的结构和训练参数需要根据实际情况进行调整，以获得更好的分类效果。同时，由于PyTorch和TensorFlow的实现方式不同，需要根据具体的框架进行代码编写。