【MNIST手写数据集数据图像可视化 (Pytorch)】

MNIST手写数据集数据处理 (Pytorch)

内容概括:

基于pytorch框架,torchvision.datasets.MNIST导入数据集,对图片数据进行预处理以及使用matplotlib可视化。

import 文件

import torch
import torchvision
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"#和python环境有关的一种设置,使程序继续运行
from torch.utils.data import DataLoader
import torch.optim as optim
from torch.optim import lr_scheduler #优化学习率
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from matplotlib import pyplot as plt

参数设置

#parameters:
lr=0.008
train_batch_size=64 
train_epochs=16
test_batch_size=1000
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

导入数据

train_dataset=torchvision.datasets.MNIST('./data/',train=True,download=True,
                                                 transform=torchvision.transforms.Compose([
                                                     torchvision.transforms.RandomHorizontalFlip(p=0.3),
                                                     torchvision.transforms.RandomVerticalFlip(p=0.3),
                                                     torchvision.transforms.ToTensor(),
                                                     torchvision.transforms.Normalize((0.1307,), (0.3081,))]))
test_dataset=torchvision.datasets.MNIST('./data/',train=False,download=True,
                                                 transform=torchvision.transforms.Compose([
                                                     torchvision.transforms.ToTensor(),
                                                     torchvision.transforms.Normalize((0.1307,), (0.3081,))]))

可视化

#查看图片
example_images,example_targets=(test_dataset._load_data())
fig = plt.figure()#生成图框
for i,c in enumerate(np.random.randint(0,1000,6)):#随机取0,1000里的6张图片
    plt.subplot(2,3,i+1) #i+1表示当前图片摆放位置,位置从1开始(故i要加1)
    plt.tight_layout()#自动调整间距
    plt.imshow(example_images[c], cmap='gray', interpolation='none')#加灰度
    plt.title("Ground Truth: {}".format(example_targets[c]))
    plt.xticks([])#x轴坐标设为空
    plt.yticks([])#y轴坐标设为空
plt.show()

注意这里为什么使用 test_dataset._load_data()
根据pytorch官方文档关于 torchvision.datasets.mnist 的解释
pytorch官网torchvision.datasets.mnist
下方_load_data 返回 data 和 target 正是我们所需得到的图像和标记
MNIST_vis_loaddata.png
可视化结果:
加灰度(cmap='gray’参数)的图像: MNIST_vis_gray.png

不加灰度的图像:

MNIST_vis_none.png

  • 10
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
好的,我了解了您的要求。实现这样的神经网络需要使用Python的NumPy库进行数学计算,并确保您已经下载了MNIST数字数据集。接下来,我将向您展示一个示例代码,它可以实现您所提出的那个问题: ```python import struct import numpy as np # 读取 MNIST 数字数据集 def read_mnist_data(): with open('train-images.idx3-ubyte', 'rb') as f: magic, num, rows, cols = struct.unpack('>4i', f.read(16)) data = np.fromfile(f, dtype=np.uint8) return data.reshape(num, -1) def read_mnist_labels(): with open('train-labels.idx1-ubyte', 'rb') as f: magic, num = struct.unpack('>2i', f.read(8)) labels = np.fromfile(f, dtype=np.uint8) return labels # 定义激活函数 sigmoid def sigmoid(x): return 1 / (1 + np.exp(-x)) # 定义 softmax 函数 def softmax(x): return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True) # 定义损失函数交叉熵 def cross_entropy(y_pred, y_true): m = y_true.shape[0] p = softmax(y_pred) loss = -1 / m * np.sum(y_true * np.log(p)) return loss # 定义正向传播函数 def forward_propagation(X, parameters): W1 = parameters['W1'] b1 = parameters['b1'] W2 = parameters['W2'] b2 = parameters['b2'] W3 = parameters['W3'] b3 = parameters['b3'] Z1 = np.dot(X, W1) + b1 A1 = sigmoid(Z1) Z2 = np.dot(A1, W2) + b2 A2 = sigmoid(Z2) Z3 = np.dot(A2, W3) + b3 A3 = softmax(Z3) cache = { 'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2, 'Z3': Z3, 'A3': A3 } return A3, cache # 定义反向传播函数 def backward_propagation(X, y, cache, parameters): A1 = cache['A1'] A2 = cache['A2'] A3 = cache['A3'] dZ3 = A3 - y dW3 = 1 / X.shape[0] * np.dot(A2.T, dZ3) db3 = 1 / X.shape[0] * np.sum(dZ3, axis=0, keepdims=True) dZ2 = np.dot(dZ3, parameters['W3'].T) * A2 * (1 - A2) dW2 = 1 / X.shape[0] * np.dot(A1.T, dZ2) db2 = 1 / X.shape[0] * np.sum(dZ2, axis=0, keepdims=True) dZ1 = np.dot(dZ2, parameters['W2'].T) * A1 * (1 - A1) dW1 = 1 / X.shape[0] * np.dot(X.T, dZ1) db1 = 1 / X.shape[0] * np.sum(dZ1, axis=0, keepdims=True) gradients = { 'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2, 'dW3': dW3, 'db3': db3 } return gradients # 定义初始参数函数 def initialize_parameters(input_size, output_size, hidden_size): W1 = np.random.randn(input_size, hidden_size) * 0.01 b1 = np.zeros((1, hidden_size)) W2 = np.random.randn(hidden_size, hidden_size) * 0.01 b2 = np.zeros((1, hidden_size)) W3 = np.random.randn(hidden_size, output_size) * 0.01 b3 = np.zeros((1, output_size)) parameters = { 'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2, 'W3': W3, 'b3': b3 } return parameters # 定义模型函数 def model(X, y, input_size, output_size, hidden_size, num_iterations, learning_rate): parameters = initialize_parameters(input_size, output_size, hidden_size) for i in range(num_iterations): y_pred, cache = forward_propagation(X, parameters) loss = cross_entropy(y_pred, y) gradients = backward_propagation(X, y, cache, parameters) parameters['W1'] -= learning_rate * gradients['dW1'] parameters['b1'] -= learning_rate * gradients['db1'] parameters['W2'] -= learning_rate * gradients['dW2'] parameters['b2'] -= learning_rate * gradients['db2'] parameters['W3'] -= learning_rate * gradients['dW3'] parameters['b3'] -= learning_rate * gradients['db3'] if i % 100 == 0: print(f"Loss after iteration {i}: {loss}") return parameters # 定义可函数 def plot_images(images, labels): import matplotlib.pyplot as plt from matplotlib.gridspec import GridSpec plt.figure(figsize=(10, 10)) gs = GridSpec(10, 10) gs.update(wspace=0.05, hspace=0.05) for i in range(100): ax = plt.subplot(gs[i]) ax.set_xticks([]) ax.set_yticks([]) ax.set_aspect('equal') plt.imshow(images[i].reshape(28, 28), cmap='gray_r') plt.title(str(int(labels[i]))) # 运行模型 X = read_mnist_data() / 255. y = np.eye(10)[read_mnist_labels()] parameters = model(X, y, input_size=X.shape[1], output_size=y.shape[1], hidden_size=20, num_iterations=1000, learning_rate=0.01) # 预测结果 y_pred, _ = forward_propagation(X, parameters) predictions = np.argmax(y_pred, axis=1) # 可结果 plot_images(X[predictions == 0], predictions[predictions == 0]) ``` 运行以上代码,即可得出 3 层隐藏层的深度神经网络对 MNIST 数字集的识别预测结果,并进行了可展示。同时,该代码无需使用 TensorFlow 或 PyTorch 框架。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值