时尚图箱分类

#调用所需要的库
import mindspore
from mindspore import nn            #MindSpore 的神经网络库，提供了构建神经网络所需的各种层、损失函数、优化器等。
from mindspore import Tensor        #MindSpore 中的张量类，类似于 NumPy 的 ndarray，用于表示和处理数据。
from mindspore.train import Model   #Model 类用于组合神经网络模型的结构和优化器等，用于训练和推理。
from mindspore.nn.metrics import Accuracy   #Accuracy 是一个度量指标，用于评估分类模型的准确率。
from mindspore.train.callback import LossMonitor   #LossMonitor 是一个回调函数，用于在训练过程中监视和打印损失值。
import mindspore.dataset as ds              #提供了数据处理和加载的功能，支持多种常见的数据集格式。
from mindspore.dataset.transforms import Compose      #mpose 是一个组合类，用于将多个数据转换函数组合在一起。
import mindspore.dataset.vision as vision     # mindspore.dataset.vision 提供了针对图像数据的处理和增强的功能，如裁剪、旋转等。
import mindspore.common.dtype as mstype      #mstype 包含了 MindSpore 支持的数据类型，如 float32、int32 等，用于指定张量的数据类型。
from mindspore.dataset.transforms import TypeCast
from torchvision import datasets



# 设置随机种子，它的作用是确保在训练神经网络或执行其他涉及随机性操作的任务时，随机数生成器的行为是可重复的。通过将随机种子设置为固定的值（例如0），可以在每次运行相同的代码时获得相同的随机结果。
mindspore.set_seed(0)



# 定义数据转换操作
transform = Compose([
    vision.Resize((28, 28)),  # 调整图像大小至28x28
    vision.Rescale(1.0 / 255.0, 0.0),  # 将像素值从[0, 255]缩放到[0, 1]    有助于模型更好的训练
    vision.Normalize(mean=[0.5], std=[0.5]),  # 使用给定的均值和标准差标准化图像
    vision.HWC2CHW()  # 从HWC格式（高度，宽度，通道）转换到CHW格式（通道，高度，宽度）  适应输入要求
])



#利用pytorch下载，并解压数据集
train_dataset = datasets.FashionMNIST(root='~/Datasets/FashionMNIST', train=True, download=True, transform=transform)
test_dataset = datasets.FashionMNIST(root='~/Datasets/FashionMNIST', train=False, download=True,transform=transform)



#自定义数据集函数
def create_dataset(training=True):
    # FashionMNIST数据集的路径
    dataset_path = "C:/Users/86188/Datasets/FashionMNIST/FashionMNIST/raw"
    fashion_mnist_ds = ds.FashionMnistDataset(dataset_path, num_parallel_workers=4, shuffle=True)

    # 应用图像转换
    fashion_mnist_ds = fashion_mnist_ds.map(operations=transform, input_columns=["image"])

    # 转换标签的数据类型为Int32
    fashion_mnist_ds = fashion_mnist_ds.map(operations=TypeCast(mstype.int32), input_columns=["label"])

    fashion_mnist_ds = fashion_mnist_ds.batch(100)                  #运用张量将图像的标签转化为数字

    return fashion_mnist_ds


#创建训练和测试数据集
train_dataset = create_dataset(training=True)
test_dataset = create_dataset(training=False)



#调用可视化库来查看训练数据集中的几张照片及其标签
import matplotlib.pyplot as plt
import numpy as np


# 函数来显示图像
def show_images(images, labels):
    _, axs = plt.subplots(1, len(images), figsize=(12, 12))
    axs = axs.flatten()
    for img, ax, label in zip(images, axs, labels):
        img = img.transpose((1, 2, 0))
        ax.imshow(img, cmap='gray')
        ax.set_title(f'Label: {label}')
        ax.axis('off')
    plt.show()
# 从训练数据集中提取一个批次的数据
batch = next(iter(train_dataset.create_dict_iterator(output_numpy=True)))
images, labels = batch["image"], batch["label"]
# 显示图像
show_images(images[:5], labels[:5])  # 显示前5张图像及其标签




#创建卷积神经网络模型，并赋予一定参数
class FashionCNN(nn.Cell):
    def __init__(self):
        super(FashionCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, pad_mode='pad', padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu = nn.ReLU()
        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, pad_mode='valid')
        self.bn2 = nn.BatchNorm2d(64)
        self.flatten = nn.Flatten()
        self.fc1 = nn.Dense(64 * 6 * 6, 600)
        self.dropout = nn.Dropout(0.25)
        self.fc2 = nn.Dense(600, 120)
        self.fc3 = nn.Dense(120, 10)

    def construct(self, x):
        x = self.max_pool2d(self.relu(self.bn1(self.conv1(x))))
        x = self.max_pool2d(self.relu(self.bn2(self.conv2(x))))
        x = self.flatten(x)
        x = self.dropout(self.fc1(x))
        x = self.fc2(x)
        x = self.fc3(x)
        return x

    def predict(self, x):
        # 将输入数据转换为Tensor，如果它还不是Tensor
        if not isinstance(x, Tensor):
            x = Tensor(x, mindspore.float32)

        # 确保模型处于评估模式
        self.set_train(False)

        # 使用模型进行预测
        return self.construct(x)

#建立模型
model = FashionCNN()



# 设立损失函数
net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
net_opt = nn.Adam(model.trainable_params(), learning_rate=0.001)

# 初始化模型
model = Model(model, loss_fn=net_loss, optimizer=net_opt, metrics={"Accuracy": Accuracy()})

# 训练模型
model.train(5, train_dataset, callbacks=[LossMonitor()], dataset_sink_mode=False)


#输出其对测试数据集的准确率
acc = model.eval(test_dataset)
print("Accuracy:", acc)


# 从测试数据集中获取一批数据
test_batch = next(iter(test_dataset.create_dict_iterator()))
test_images, test_labels = test_batch["image"], test_batch["label"]


# 使用模型进行预测
predicted = model.predict(test_images)


# 将预测结果转换为NumPy数组并获取最可能的类别
predicted_labels = np.argmax(predicted.asnumpy(), axis=1)
label_names = {
    0: 'T-shirt/top',
    1: 'Trouser',
    2: 'Pullover',
    3: 'Dress',
    4: 'Coat',
    5: 'Sandal',
    6: 'Shirt',
    7: 'Sneaker',
    8: 'Bag',
    9: 'Ankle boot'
}

# 将标签转换为名称
actual_names = [label_names[label] for label in test_labels.asnumpy()]
predicted_names = [label_names[label] for label in predicted_labels]

# 显示实际标签和预测标签的名称
print("Actual labels: ", actual_names)
print("Predicted labels: ", predicted_names)