实验——神经网络预测Fashion-MNIST数据集

最新推荐文章于 2024-07-24 15:16:19 发布
最新推荐文章于 2024-07-24 15:16:19 发布
阅读量6.3k 收藏 63
点赞数 17
分类专栏： 机器学习 文章标签： 概率论 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45785407/article/details/121594352
版权

文章目录

一 实验数据

Fashion-MNIST数据集，数据集中包含 60000 张训练样本，10000 张测试 样本，可将训练样本划分为49000 张样本的训练集和1000 张样本的验证集，测 试集可只取1000 张测试样本。其中每个样本都是 28×28 像素的灰度照片，每 个像素点包括RGB三个数值，数值范围0 ~ 255，所有照片分属10个不同的类别。

灰度与像素值的关系：

  • 图像的灰度化： 灰度就是没有色彩，RGB色彩分量全部相等。图像的灰度化就是让像素点矩阵中的每一个像素点都满足关系：R=G=B，此时的这个值叫做灰度值。如RGB(100,100,100)就代表灰度值为100,RGB(50,50,50)代表灰度值为50。

  • 灰度值与像素值的关系： 如果对于一张本身就是灰度图像（8位灰度图像）来说，他的像素值就是它的灰度值，如果是一张彩色图像，则它的灰度值需要经过函数映射来得到。灰度图像是由纯黑和纯白来过渡得到的，在黑色中加入白色就得到灰色，纯黑和纯白按不同的比例来混合就得到不同的灰度值。R=G=B=255为白色，R=G=B=0为黑色，R=G=B=小于255的某个整数时，此时就为某个灰度值。

二 实验要求

  1. 用神经网络对给定的数据集进行分类，画出loss图，给出在测试集上的精确度；

  2. 不能使用 pytorch 等框架，也不能使用库函数，所有算法都要自己实现

  3. 神经网络结构图如下图所示：

    在这里插入图片描述

  4. 整个神经网络包括 3 层——输入层，隐藏层，输出层。输入层有28x28x3个神经元，隐藏层有 50个神经元，输出层有 10 个神经元（对应 10 个类别）。

  5. 附加：可以试着修改隐藏层神经元数，层数，学习率，正则化权重等参数探究参数对实验结果的影响

三 实验思路与代码

实验要求设计一个三层的全连接神经网络，实现分类的功能。实验原理请见我的博客：神经网络基础与反向传播_Sunburst7的博客-CSDN博客

神经网络的每次迭代主要包括以下几个步骤：

  • 传入训练图片灰度矩阵/数组
  • 进行前馈运算，计算出输出层10个神经元预测的标签
  • 与期望的标签计算Loss，更新隐含层（Hidden）到输出层（Output）的权值
  • 计算隐含层的敏感度，更新输入层（Input）到隐含层的权值
  • 传入测试图片灰度矩阵，进行预测。
  • 统计

起初我的设计充满了面向对象的思想，导致在进行大数据集的运算时消耗时间很长，无法训练神经网络，受到参考【2】【3】【4】中博客的启发，改变思路，采用矩阵运算的思想成功训练出一个良好的神经网络。

3.1 初始的设想

我准备编写一个神经元类表示单个神经元，该神经元有以下属性，手绘原理图：

在这里插入图片描述

  • 权值数组Weights：上一层与该神经元相连的所有神经元的权值

  • 偏置Bias

  • 输入值数组Inputs与输出值Output

  • 激活函数

  • 敏感度：定义可见实验原理博客

  • 神经元类型Type：标识是输入层还是输出层还是隐含层神经元

每个神经元有两个函数，分别代表前馈与反向传播。

  • 前馈：将输入值与权值进行向量的内积，加上偏置，在传入激活函数，输出最后的值
  • 反向传播：对于输入层与输出层不同，利用传入的敏感度数组与权值数组更新自身的权值矩阵。
import numpy as np

def sigmoid(x):
    if x>=0:      #对sigmoid函数的优化，避免了出现极大的数据溢出
        return 1.0/(1+np.exp(-x))
    else:
        return np.exp(x)/(1+np.exp(x))

class Neuron:
    def __init__(self, weights, bias, ntype):
        # 上一层与之相连的weights array
        self.weights = weights
        # 偏置 bias
        self.bias = bias
        # input array
        self.inputs = 0
        # 总的输出 z_k
        self.output = 0
        # 一个神经元的敏感度
        self.sensitivity = 0.0
        # 神经元的类型:Input Hidden Output
        self.ntype = ntype

    def __str__(self):
        return "weights: \n"+str(self.weights)+"\nbias:\n"+str(self.bias)+"\ninputs:\n"+str(self.inputs)+"\noutput:\n"+str(self.output)+"\nsensitivity\n"+str(self.sensitivity)+"\ntype:\n"+str(self.ntype)

    def feedForward(self, inputs:np.array):
        """
        前馈
        :param inputs: 输入的向量
        :return:
        """
        self.inputs = inputs
        # weight inputs, add bias, then use the activation function
        total = np.dot(self.weights, self.inputs) + self.bias
        # 计算神经元的输出
        # 如果是输入层，不需要带入激活函数f
        if self.ntype == 'Input':
            self.output = total
        else:
            self.output = sigmoid(total)
        return self.output


    def backPropagation(self ,eta ,tk ,sensitivities ,weights):
        """
        反向传递更新权值
        :param eta: 学习率
        :param tk: 真实标签
        :param sensitivities: 该神经元如果不是输出层，隐含层下一层所有神经元的敏感度
        :param weights: 该神经元如果不是输出层，与该神经元相连的下一层的所有权值
        :return:
        """
        if self.ntype == 'Output':
            # 计算f'(net)=f(net)*(1-f(net))
            derivative_f = self.output*(1-self.output)
            # 计算loss'(zk)=-(tk-zk)
            derivative_loss = -(tk - self.output)
            # 计算该神经元的敏感度 sensitivity = -f'(net)*loss'(zk)
            self.sensitivity = -derivative_f*derivative_loss
            # 更新权重
            self.weights = self.weights + eta*self.sensitivity*np.array(self.inputs)
        elif self.ntype == 'Hidden':
            # 计算f'(net)=f(net)*(1-f(net))
            derivative_f = self.output * (1 - self.output)
            # 计算隐含层单元的敏感度 sensitivity = f'(net)*<下一层所有神经元的敏感度，该神经元与下一层相连的权重>
            self.sensitivity = derivative_f*np.dot(sensitivities,weights)
            # 更新权重
            self.weights = self.weights + eta*self.sensitivity*np.array(self.inputs)
        else:
            return

再编写一个神经网络类构造三层神经元并进行feedForward与backPropagation的参数传递工作：

import numpy as np
import os
import gzip
from exp4.Neuron1 import Neuron

def sigmoid(x):
    if x>=0:      #对sigmoid函数的优化，避免了出现极大的数据溢出
        return 1.0/(1+np.exp(-x))
    else:
        return np.exp(x)/(1+np.exp(x))

# 定义加载数据的函数，加载4个zip格式文件
def load_data(data_folder):
  files = [
      'train-labels-idx1-ubyte.gz', 'train-images-idx3-ubyte.gz',
      't10k-labels-idx1-ubyte.gz', 't10k-images-idx3-ubyte.gz'
  ]
  paths = []
  for fname in files:
    paths.append(os.path.join(data_folder,fname))
  with gzip.open(paths[0], 'rb') as lbpath:
    y_train = np.frombuffer(lbpath.read(), np.uint8, offset=8)
  with gzip.open(paths[1], 'rb') as imgpath:
    x_train = np.frombuffer(
        imgpath.read(), np.uint8, offset=16).reshape(len(y_train), 28, 28)
  with gzip.open(paths[2], 'rb') as lbpath:
    y_test = np.frombuffer(lbpath.read(), np.uint8, offset=8)
  with gzip.open(paths[3], 'rb') as imgpath:
    x_test = np.frombuffer(
        imgpath.read(), np.uint8, offset=16).reshape(len(y_test), 28, 28)
  return (x_train, y_train), (x_test, y_test)


def makeTrueLabels(trueLabel):
    """
    生成传递给输出层的期望标签数组
    :param trueLabel:
    :return:
    """
    labels = []
    for i in range(10):
        if trueLabel == i:
            labels.append(1)
        else:
            labels.append(0)
    return labels


class NeuronNetwork:
    def __init__(self,train_images,train_labels,test_images,test_labels):
        self.inputLayer = []
        self.hiddenLayer = []
        self.outputLayer = []
        self.train_images = train_images
        self.train_labels = train_labels
        self.test_images = test_images
        self.test_labels = test_labels

        # 从输入层到隐含层权值的初始化
        initWeight_1 = np.random.uniform(-1/np.sqrt(784),1/np.sqrt(784),(50,784))
        # 从隐含层到输出层权值的初始化
        initWeight_2 = np.random.uniform(-1/np.sqrt(50),1/np.sqrt(50),(10,50))
        # 偏置初始化
        bias = np.random.normal(0,0.5,2)

        # 初始化输入层
        for i in range(784):
            neuron = Neuron(1,0,ntype='Input')
            self.inputLayer.append(neuron)

        # 初始化隐藏层
        for i in range(50):
            neuron = Neuron(initWeight_1[i],bias[0],ntype='Hidden')
            self.hiddenLayer.append(neuron)

        # 初始化输出层
        for i in range(10):
            neuron = Neuron(initWeight_2[i],bias[1],ntype='Output')
            self.outputLayer.append(neuron)


    def iteration(self):
        T = 0
        N = 0

        # 依次将60000章图片训练一边
        for m in range(self.train_images.shape[0]):
            # 输入层(784个神经元)的输出
            y_i = []
            # 对于每张图片的784个像素点
            for row in range(self.train_images.shape[1]):
                for col in range(self.train_images.shape[2]):
                    y_i.append(
                        self.inputLayer[28 * row + col].feedForward(inputs=np.array(train_images[m][row][col]))
                    )


            # 隐藏层(50个神经元)的输出
            y_h = []
            for hidden_neuron in self.hiddenLayer:
                y_h.append(hidden_neuron.feedForward(y_i))


            # 输出层的标签：预测标签
            y_o = []
            for output_neuron in self.outputLayer:
                y_o.append(output_neuron.feedForward(y_h))

            # 进行预测，统计预测正误
            forecastLabel = y_o.index(np.array(y_o).max())
            if forecastLabel == train_labels[m]:
                T+=1
            else:
                N+=1

            # 期望值数组
            trueLabels = makeTrueLabels(trueLabel=forecastLabel)

            # 对输出层进行反向传播
            output_sensitivities = [] # 输出层所有节点的敏感度
            output_weights = [] # 输出层所有节点的权重
            for i in range(10):
                self.outputLayer[i].backPropagation(eta=0.1,tk=trueLabels[i],sensitivities=None,weights=None)
                # 保存更新过的敏感度
                output_sensitivities.append(self.outputLayer[i].sensitivity)
                output_weights.append(self.outputLayer[i].weights)

            # 对隐含层进行反向传播
            for i in range(50):
                # 隐含层每个神经元连接的10个输出层神经元的权值
                linkedWeights = [arr[i] for arr in output_weights]
                self.hiddenLayer[i].backPropagation(eta=0.1,tk=None,sensitivities=output_sensitivities,weights=linkedWeights)

        return T, N


# 传入数据集
(train_images, train_labels), (test_images, test_labels) = load_data('')
train_images = train_images[0:500:1]
train_labels = train_labels[0:500:1]
"""
    定义统计信息：

"""
n = 100
positive = []
negative = []
nn = NeuronNetwork(train_images=train_images,train_labels=train_labels,test_images=test_images,test_labels=test_labels)
for k in range(100):
    T,N = nn.iteration()
    positive.append(T)
    negative.append(N)

该神经网络只能运行在少量的样本上，不能满足需要

在这里插入图片描述

3.2 改进思路：矩阵运算

之前思路中更新的过程太慢，每次都要一张一张图片传入，同时大量的对象也拖慢了运算的速度，因此我取消了神经元类，而在神经网络中保存两个矩阵，分别代表从输入层到隐含层与从隐含层到输出层的权值。

在这里插入图片描述

神经网络类通过输入层节点数、隐含层节点数、输出层节点数、学习率进行初始化，同时初始化两个权值矩阵以及一个偏置数组。

# 制作一个神经网络算法的类，其名为神经网络，相当于函数库，直接进行调用里面的函数即可。
class NeuralNetwork:
    def __init__(self,inputNeurons,hiddenNeurons,outputNeurons,lr):
        """
        神经网络构造方法
        :param inputNeurons:输入层神经元个数
        :param hiddenNeurons:隐含层神经元个数
        :param outputNeurons:输出层神经元个数
        :param lr:学习率
        """
        self.iNeuron_num = inputNeurons
        self.hNeuron_num = hiddenNeurons
        self.oNeuron_num = outputNeurons
        self.learnRate = lr # 学习率
        self.f = lambda x: ssp.expit(x) # 设置激活函数f为Sigmod(x)激活函数

        # 设置输入层与隐藏层直接的权重关系矩阵以及隐藏层与输出层之间的权重关系矩阵,初始值为正态分布
        self.weights_i_h = np.random.normal(0.0, 1/np.sqrt(hiddenNeurons), (self.hNeuron_num, self.iNeuron_num))
        self.weights_h_o = np.random.normal(0.0, 1/np.sqrt(hiddenNeurons), (self.oNeuron_num, self.hNeuron_num))
        # 偏置初始化
        self.bias = np.random.normal(0, 0.5, 2)

对输入的图片与标签进行两步处理：

  • 归一化

    • 对于图片将所有的灰度(0-255)全部映射到(0.01-0.99)上
    • 对于每一个表示分类结果的标签(0-9)重新构造一个长度为10的数组，下标对应每个标签，若真实分类标签为8，则数组[7] = 0.99，其他位置的值为0.01，近似表示该图片真实标签的概率。
    # 对60000张图片进行遍历
for i in range(60000):
    # 测试集的28*28矩阵转化为784的一维数组
    img = train_images[i].reshape(train_images.shape[1]*train_images.shape[2])
    # 进行归一化：除以255，再乘以0.99，最后加上0。01，保证所有的数据都在0.01到1.00之间
    train_matrix[:,i] = (img/255.0)*0.99+0.01
    # 建立准确输出结果矩阵，对应的位置标签数值为0.99，其他位置为0.01
    # 第i张图片代表第i列，行数代表正确的标签
    train_labels_matrix[train_labels[i],i] = 0.99
    
# 对10000章测试集图片进行处理
for i in range(10000):
    # 训练集的28*28矩阵转化为784的一维数组
    test_img = test_images[i].reshape(test_images.shape[1] * test_images.shape[2])
    # 更新输入到神经网络中的训练集矩阵
    test_matrix[:,i] = (test_img/255.0)*0.99+0.01
    # 建立准确输出结果矩阵，对应的位置标签数值为0.99，其他位置为0.01
    test_label_matrix[test_labels[i],i] = 0.99

  • Reshape：将输入的图片灰度与标签从新组合

    在这里插入图片描述

整个前馈的矩阵运算的过程如图：

在这里插入图片描述

BP的过程主要分为两个部分：

  • 对于输出层到隐含层：

    计算f'(net) = f(net)*(1-f(net))
计算loss'(zk)=-(tk-zk)
计算对于每张图片该神经元的敏感度(10,60000):
sensitivity = -f'(output_f_net)*loss'(zk) = (tk-zk)*f(output_f_net)*(1-f(output_f_net))[矩阵对应位置相乘]
更新权重:学习率*敏感度(10,60000) @ 50个隐含层层神经元的输出(60000,50)

  • 对于隐含层到输入层：

    计算对于每张图片50个隐含层神经元的每一个神经元的从输出层传入的敏感度（50*60000)：
输出层敏感度的加权和*f'(net)
更新权重

完整的训练过程如下：

    def train(self,featuresMatrix,targetMatrix,iterateNum):
        """
        神经网络一次训练
        :param featuresMatrix: 784*60000的图片灰度矩阵 也是隐含层的输入
        :param targetMatrix: 10*60000的期望值矩阵 tk
        :param iterateNum: 迭代序号
        :return: 返回训练正确率
        """
        T = 0
        N = 0

        # 前馈 feedforward
        # 隐藏层net（50*60000）计算
        hidden_net = (self.weights_i_h @ featuresMatrix)+self.bias[0]
        # 隐藏层输出f(hidden_net)
        hidden_f_net = self.f(hidden_net)
        # 输出层net(10*60000) 计算
        output_net = (self.weights_h_o @ hidden_f_net)+self.bias[1]
        # 输出层输出f(output_net) zk
        output_f_net = self.f(output_net)

        # 统计网络预测正确率
        for imgIndex in range(60000):
            # 返回输出层10个神经元最大值下标 与 预测标签
            if output_f_net[:,imgIndex].argmax() == targetMatrix[:,imgIndex].argmax():
                T+=1
            else:
                N+=1
        print("第"+iterateNum+"次训练集迭代正确率："+str(T/60000))


        # 反向传播运算 backPropagation
        # 对于输出层到隐含层
        output_errors = targetMatrix - output_f_net
        # 计算f'(net) = f(net)*(1-f(net))
        # 计算loss'(zk)=-(tk-zk)
        # 计算对于每张图片该神经元的敏感度(10,60000) sensitivity = -f'(net)*loss'(zk) = (tk-zk)*f(net)*(1-f(net))[矩阵对应位置相乘]
        sensitivities = output_errors * output_f_net * (1.0 - output_f_net)
        # 更新权重 学习率* 敏感度(10,60000) @ 50个隐含层层神经元的输出(60000,50)
        self.weights_h_o += self.learnRate * (sensitivities @ hidden_f_net.T)
        # 对于隐含层到输入层
        # 计算对于每张图片50个隐含层神经元的每一个敏感度（50*60000） = 输出层敏感度的加权和*f'(net)
        hidden_sensitivities = (self.weights_h_o.T @ sensitivities) * hidden_f_net * (1 - hidden_f_net)
        # 更新权重
        self.weights_i_h += self.learnRate * ( hidden_sensitivities @ featuresMatrix.T)
        
        return T/60000

预测的过程就是进行一遍前馈的过程：

    def test(self,testMatrix,targetMatrix,iterateNum):
        """
        利用神经网络对训练集进行一次测试
        :param testMatrix: 784*10000的灰度矩阵
        :param targetMatrix: 10*10000的预测标签矩阵
        :param iterateNum: 迭代序号
        :return: 返回训练正确率
        """
        T = 0
        N = 0
        # 前馈 feedforward
        # 隐藏层net（50*60000）计算
        hidden_net = (self.weights_i_h @ testMatrix) + self.bias[0]
        # 隐藏层输出f(hidden_net)
        hidden_f_net = self.f(hidden_net)
        # 输出层net(10*60000) 计算
        output_net = (self.weights_h_o @ hidden_f_net) + self.bias[1]
        # 输出层输出f(output_net) zk
        output_f_net = self.f(output_net)

        # 统计网络预测正确率
        for imgIndex in range(10000):
            # 返回输出层10个神经元最大值下标 与 预测标签
            if output_f_net[:, imgIndex].argmax() == targetMatrix[:, imgIndex].argmax():
                T += 1
            else:
                N += 1
        print("第" + iterateNum + "次测试集迭代正确率：" + str(T / 10000))
        return T / 10000

调试与结果展示代码如下：

# 导入数据
(train_images, train_labels), (test_images, test_labels) = load_data('')
# 输出图片
# plt.imshow(train_images[0], cmap='Greys', interpolation='None')
# 初始化输入数据矩阵
train_matrix = np.zeros((784,60000))
test_matrix = np.zeros((784,10000))
# 初始化输出层期望值矩阵
train_labels_matrix = np.zeros((10,60000))+0.01
test_label_matrix = np.zeros((10,10000))+0.01

# 对60000张图片进行遍历
for i in range(60000):
    # 测试集的28*28矩阵转化为784的一维数组
    img = train_images[i].reshape(train_images.shape[1]*train_images.shape[2])
    # 进行归一化：除以255，再乘以0.99，最后加上0。01，保证所有的数据都在0.01到1.00之间
    train_matrix[:,i] = (img/255.0)*0.99+0.01
    # 建立准确输出结果矩阵，对应的位置标签数值为0.99，其他位置为0.01
    # 第i张图片代表第i列，行数代表正确的标签
    train_labels_matrix[train_labels[i],i] = 0.99

# 对10000章测试集图片进行处理
for i in range(10000):
    # 训练集的28*28矩阵转化为784的一维数组
    test_img = test_images[i].reshape(test_images.shape[1] * test_images.shape[2])
    # 更新输入到神经网络中的训练集矩阵
    test_matrix[:,i] = (test_img/255.0)*0.99+0.01
    # 建立准确输出结果矩阵，对应的位置标签数值为0.99，其他位置为0.01
    test_label_matrix[test_labels[i],i] = 0.99

# 学习率
learn_rate = 0.000025
# 迭代次数
epochs = 100
# 初始化神经网络
nn = NeuralNetwork(784,50,10,learn_rate)
# 准确率数组
train_accuracy = []
test_accuracy = []
# 进行迭代
for i in range(epochs):
    train_accuracy.append( nn.train(train_matrix,train_labels_matrix,str(i)) )
    test_accuracy.append( nn.test(test_matrix,test_label_matrix,str(i)) )
# 画图
plt.plot(range(1,epochs+1),train_accuracy,'y')
plt.plot(range(1,epochs+1),test_accuracy,'g')
plt.legend(labels = ('train accuracy', 'test accuracy'), loc = 'lower right') # legend placed at lower right
plt.title("learn rate: "+str(learn_rate))
plt.xlabel('iteration')
plt.ylabel('accuracy')
plt.show()

四 实验结果分析

当学习率为0.1时，由于学习率过大导致更新的权重过大使得权重数组全为负值，继而在之后的迭代中计算激活能时是一个极大的复数，带入sigmod函数趋近于0，从而导致权值不再更新，正确率维持在0.1更新。

在这里插入图片描述
在这里插入图片描述

解决的方法是降低学习率，不让权值更新的过快，将学习率降低为0.000025时，迭代50次，整个模型有很大的优化：

在这里插入图片描述

提高迭代次数至200次，预测正确率可以达到75%左右：

在这里插入图片描述

参考：

【1】神经网络基础与反向传播_Sunburst7的博客-CSDN博客

【2】识别MNIST数据集之（二）：用Python实现神经网络_superCally的专栏-CSDN博客

【3】 用python创建的神经网络–mnist手写数字识别率达到98%_学习机器学习-CSDN博客_mnist手写数字识别python

【4】利用Python对MNIST手写数据集进行数字识别（初学者入门级）_仲子_real-CSDN博客_mnist手写数字识别python

Sunburst7
关注
  • 17
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深度学习实例4_fashion_mnist分类——自学笔记
Rrrrrr900的博客
05-10 310
损失函数（loss）：用于测量模型在训练期间的准确率。您会希望最小化此函数，以便将模型“引导”到正确的方向上。指标（metrics）：用于监控训练和测试步骤。以下示例使用了准确率，即被正确分类的图像的比率。优化器（optimizer）：决定模型如何根据其看到的数据和自身的损失函数进行更新。train_images&train_labels是训练集，模型用于学习。test_iamges&test_labels是测试集，用于测试。将像素的值标准化到[0,1]区间内。
fashion-mnist.zip
05-24
今天我们要探讨的是一个非常流行的数据集——Fashion-MNIST，它由Zalando公司发布，用以替代传统的MNIST数据集，用于入门级的图像识别任务。Fashion-MNIST数据集被封装在名为“fashion-mnist.zip”的压缩文件中，...
(保姆级)Pytorch构建神经网络的简单实例——对FashionMNIST数据集图像进行分类（源代码来源于Pytorch计算机视觉实战第三章）
Zssss12的博客
02-05 626
FashionMNIST（时尚MNIST）是一个经典的计算机视觉数据集，用于图像分类任务。它是由 Zalando Research 创建的，旨在替代传统的MNIST数据集，以更贴近实际场景中的图像分类问题。FashionMNIST数据集包含了60,000个用于训练的图像样本和10,000个用于测试的图像样本，总共包括10个类别。每个样本都是灰度图像，分辨率为28x28像素。每个像素的值介于0到255之间，表示像素的灰度强度。数据集中的图像样本代表了不同种类的时尚商品，包括衣服、鞋子、手袋等。
Tensorflow实现AlexNet卷积神经网络——Fashion-MNIST数据集分类
qq_24819773的博客
03-11 3960
论文地址：http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf Fashion-MNIST数据集下载：https://github.com/zalandoresearch/fashion-mnist/tree/master/data/fashion ...
动手学深度学习（九+）——softmax分类Fashion-MNIST数据集
Liu Feng's Blog
07-18 3639
文章目录一、Fashion-MNIST数据集1.1 认识数据集1.2 小批量读取数据二、softmax回归从零开始实现2.1 初始化模型参数2.2 定义softmax函数及网络模型2.3 定义交叉熵损失函数2.4 训练数据2.5 测试模型三、使用pytorch简单地实现softmax回归 jupyter编程，更改为pytho脚本请自行修改。整体基于李沐老师的动手学习深度学习-pytorch 2021版。下面是个人模仿代码和笔记，主要用于个人复习，如有错误请告知。 一、Fashion-MNIST数据集 F
神经网络衣服分类器详解（Fashion-MNIST数据集）
weixin_43873671的博客
01-30 1万+
文章目录前言一、Fashion-MNIST是什么？二、代码实现1.引入库2.读取数据集3.数据预处理4.搭建神经网络5.编译和训练神经网络模型6.神经网络预测总结 前言 每个想要学习深度学习、图像识别的同学，想要用到神经网络，入门的实例必定是MNIST手写数字集，这是所有人都绕不开的，我也是，我之前写了三篇关于MNIST的博文。en…但这个数据集毕竟只有手写数字，有时候并不是能够满足我们开发的要求，于是，Fashion-MNIST出现了。 提示：以下是本篇文章正文内容，下面案例可供参考 一、Fash
神经网络入门及改进优化——CNN识别Fashion-MNIST数据集（Python实现）
Louvre的博客
07-24 1633
适用于 TensorFlow 2.3 及 keras 2.4.3 ，Python版本为3.8 图像分类数据集中最常用的是手写数字识别数据集MNIST 。但大部分模型在MNIST上的分类精度都超过了95%。为了更直观地观察算法之间的差异，我们将使用一个图像内容更加复杂的数据集Fashion-MNIST FashionMNIST 是图像数据集，它是由 Zalando（一家德国的时尚科技公司）旗下的研究部门提供。其涵盖了来自 10 种类别的共 7 万个不同商品的正面图片。FashionMNIST 的大小、格.
【深度学习系列】——Fashion-MNIST数据集简介
热门推荐
weixin_45666566的博客
08-05 2万+
图像分类数据集（Fashion-MNIST）1、数据集简介2、获取数据集3、查看数据集4、图像可视化显示5、读取小批量数据 1、数据集简介 \quad \quad不同于MNIST手写数据集，Fashion-MNIST数据集包含了10个类别的图像，分别是：t-shirt（T恤），trouser（牛仔裤），pullover（套衫），dress（裙子），coat（外套），sandal（凉鞋），shirt（衬衫），sneaker（运动鞋），bag（包），ankle boot（短靴）。 2、获取数据集 1、torch
Tensorflow 笔记 XIII——“百无聊赖”：深挖 mnist 数据集与 fashion-mnist 数据集的读取原理，经典数据的读取你真的懂了吗？
DeepHao'Blog
05-24 1625
文章目录数据集简介Mnist出门右转Fashion-Mnist数据集制作需求来源写给专业的机器学习研究者获取数据类别标注读取原理原理获取TRAINING SET LABEL FILE (train-labels-idx1-ubyte)TRAINING SET IMAGE FILE (train-images-idx3-ubyte)TEST SET LABEL FILE (t10k-labels-idx1-ubyte)TRAINING SET IMAGE FILE (train-images-idx3-uby
TensorFlow学习笔记——Fashion-MNIST数据集的下载及本地保存
weixin_40730615的博客
08-05 2625
Fashion-MNIST是Zalando文章图像的数据集——包括60,000个示例的训练集和10,000个示例的测试集。每个示例都是一个28x28灰度图像，与来自10个类的标签相关联。 Fashion-MNIST Here is the example how the data looks (each class takes three-rows): label description 0 T恤（T-shirt/top） 1 裤子（Trouser） 2 套头衫（Pullov
【深度学习】搭建类似LeNet-5网络识别Fashion-MNIST数据集(衣服，鞋子等)
weixin_46274756的博客
11-14 1153
【深度学习】搭建类似LeNet-5网络识别Fashion-MNIST数据集(衣服，鞋子等)
FashionMNIST数据集.zip
02-20
《FashionMNIST数据集——深度学习的时尚起点》 FashionMNIST数据集是深度学习领域一个广泛使用的入门级数据集，特别适用于初学者实践和理解卷积神经网络（CNN）的工作原理。它由Zalando Research团队创建，旨在...
VGG-16服饰识别Fashion-MNIST.py
01-07
Fashion-MNIST 是一个替代 MNIST 手写数字集的图像数据集。 它是由 Zalando（一家德国的时尚科技公司）旗下的研究部门提供。其涵盖了来自 10 种类别的共 7 万个不同商品的正面图片。 ——————————————...
ResNet-18服饰识别Fashion-MNIST.py
01-07
残差神经网络(ResNet) 是由微软研究院的 何...Fashion-MNIST 是一个替代 MNIST 手写数字集的图像数据集。 ———————————————— 原文链接：https://blog.csdn.net/qq_63585949/article/details/127740902
NiN服饰识别Fashion-MNIST.py
01-07
Network In Network (NIN) 是由 Min Lin 等人...Fashion-MNIST 是一个替代 MNIST 手写数字集的图像数据集。 ———————————————— 原文链接：https://blog.csdn.net/qq_63585949/article/details/127723218
【概率论】第一章：概率论基本概念
hiliang521的博客
07-23 573
概率论基本概念
概率论中的卷积公式
2302_80644606的博客
07-20 1764
在概率论中，卷积公式是用于计算两个独立随机变量之和的概率密度函数的重要工具。具体来说，如果 𝑋X 和 𝑌Y 是两个独立的连续型随机变量，其概率密度函数分别为 𝑓𝑋(𝑥)fX​(x) 和 𝑓𝑌(𝑦)fY​(y)，那么它们和 𝑍=𝑋+𝑌Z=X+Y 的概率密度函数 𝑓𝑍(𝑧)fZ​(z) 可以通过卷积公式来求得：这个公式表示的是对 𝑓𝑋(𝑥)fX​(x) 进行平移和翻转后与 𝑓𝑌(𝑦)fY​(y) 相乘并积分的过程。
【概率论】-2-概率论公理(Axioms of Probability)
最新发布
qq_51566832的博客
07-24 835
通俗讲述概率论之概率论公理
针对Fashion-MNIST数据集建立神经网络实现对图片分类的预测，首先读取Fashion-MNIST数据集，完成神经网络的推理和批处理过程
09-26
针对Fashion-MNIST数据集建立神经网络实现对图片分类的预测，首先需要读取Fashion-MNIST数据集并完成神经网络的推理和批处理过程。根据提供的引用，可以使用PyTorch来构建多层感知机（MLP）或卷积神经网络（CNN）来进行分类。 在代码中，需要做以下几个步骤： 1. 导入必要的库和模块。 2. 加载Fashion-MNIST数据集，并进行数据预处理（例如标准化、转换为张量）。 3. 定义神经网络的结构，包括层的数量、类型和大小。 4. 定义损失函数（如交叉熵损失）和优化器（如随机梯度下降）。 5. 进行训练循环，包括前向传播、计算损失、反向传播和参数更新。 6. 定义评估函数来评估模型在验证集或测试集上的性能。 7. 进行批处理，将数据分成小批次进行训练。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sunburst7

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值