0
点赞
收藏
分享

微信扫一扫

数字识别的神经网络（个人笔记）

AbrahamW 2022-01-23 阅读 66
神经网络机器学习深度学习

数字识别的神经网络

一、不含迭代次数的代码

import  numpy as np
import torch
from torch.utils.data import DataLoader
import torchvision.datasets as dsets
import torchvision.transforms as transforms

#对数损失函数
def cross_entropy_error(p, y):
    delta = 1e-7
    batch_size = p.shape[0]
    return -np.sum(y * np.log(p + delta)) / batch_size
    #激活函数
def _softmax(x):
    if x.ndim == 2:
        c = np.max(x, axis=1)
        x = x.T - c  # 溢出对策
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T
    c = np.max(x)
    exp_x = np.exp(x - c)
    return exp_x / np.sum(exp_x)
#梯度下降法
def numerical_gradient(f, x):
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)

    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # f(x+h)

        x[idx] = tmp_val - h
        fxh2 = f(x)  # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)

        x[idx] = tmp_val  # 还原值
        it.iternext()

    return grad
def relu(in_data):
    return np.maximum(0, in_data)
class TwoLayerNet:
#初始化
    def __init__(self,input_size,hidden_size,output_size,weight_init_std=0.01):
        self.params={}
        self.params['W1'] = weight_init_std*np.random.randn(input_size,hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size,output_size)
        self.params['b2'] = np.zeros(output_size)




#前向传播
    def predict(self,x):
        W1,W2 = self.params['W1'],self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        a1 = np.dot(x,W1)+b1
        z1 =relu(a1)
        a2 = np.dot(z1,W2) + b2
        p=_softmax(a2)
        return p
    def loss(self,x,y):
        p = self.predict(x)
        return cross_entropy_error(p,y)

    def numerical_gradient2(self, x, y):

        loss_W = lambda W: self.loss(x, y)
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        return grads
# 预测
    def accuracy(self, x, t):
        p = self.predict(x)
        p = np.argmax(x, axis=1)
        y = np.argmax(t, axis=1)
        accuracy = np.sum(p == y) / float(x.shape[0])
        return accuracy
if __name__ == '__main__':

#加载数据集
    train_dataset = dsets.MNIST(root='/ml/pymnist',  # 选择数据的根目录
                                train=True,  # 选择训练集
                                transform=None,  # 不考虑使用任何数据预处理
                                download=True)  # 从网络上download图片
    test_dataset = dsets.MNIST(root='/ml/pymnist',  # 选择数据的根目录
                               train=False,  # 选择测试集
                               transform=None,  # 不考虑使用任何数据预处理
                               download=True)  # 从网络上download图片
  #获得测试数据和数据集的数据以及标签                             
    x_train = train_dataset.data.numpy().reshape(-1,28*28)
    y_train_temp = train_dataset.targets.reshape(train_dataset.targets.shape[0],1)
    y_train = torch.zeros(y_train_temp.shape[0],10).scatter_(1,y_train_temp,1).numpy()
    x_test = test_dataset.data.numpy().reshape(-1,28*28)
    y_test_temp = train_dataset.targets.reshape(train_dataset.targets.shape[0], 1)
    y_test = torch.zeros(y_test_temp.shape[0], 10).scatter_(1, y_test_temp, 1).numpy()

    # 超参数
    iters_num = 1000  # 适当设定循环的次数
    train_size = x_train.shape[0]
    batch_size = 100
    learning_rate = 0.001
# 初始化神经网络
    network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
    for i in range(iters_num):
        batch_mask = np.random.choice(train_size, batch_size)
        x_batch = x_train[batch_mask]
        y_batch = y_train[batch_mask]

        grad = network.numerical_gradient2(x_batch, y_batch)

        for key in ('W1', 'b1', 'W2', 'b2'):
            network.params[key] -= learning_rate * grad[key]

        # 记录学习过程
        loss = network.loss(x_batch, y_batch)
        if i % 100 == 0:
            print(loss)

在这里插入图片描述

含迭代次数的代码

import  numpy as np
import torch
from torch.utils.data import DataLoader
import torchvision.datasets as dsets
import torchvision.transforms as transforms


def cross_entropy_error(p, y):
    delta = 1e-7
    batch_size = p.shape[0]
    return -np.sum(y * np.log(p + delta)) / batch_size
def _softmax(x):
    if x.ndim == 2:
        c = np.max(x, axis=1)
        x = x.T - c  # 溢出对策
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T
    c = np.max(x)
    exp_x = np.exp(x - c)
    return exp_x / np.sum(exp_x)

def numerical_gradient(f, x):
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)

    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # f(x+h)

        x[idx] = tmp_val - h
        fxh2 = f(x)  # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)

        x[idx] = tmp_val  # 还原值
        it.iternext()

    return grad
def relu(in_data):
    return np.maximum(0, in_data)
class TwoLayerNet:
    def __init__(self,input_size,hidden_size,output_size,weight_init_std=0.01):
        self.params={}
        self.params['W1'] = weight_init_std*np.random.randn(input_size,hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size,output_size)
        self.params['b2'] = np.zeros(output_size)





    def predict(self,x):
        W1,W2 = self.params['W1'],self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        a1 = np.dot(x,W1)+b1
        z1 =relu(a1)
        a2 = np.dot(z1,W2) + b2
        p=_softmax(a2)
        return p
    def loss(self,x,y):
        p = self.predict(x)
        return cross_entropy_error(p,y)

    def numerical_gradient(self, x, y):

        loss_W = lambda W: self.loss(x, y)
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        return grads

    def accuracy(self, x, t):
        p = self.predict(x)
        p = np.argmax(x, axis=1)
        y = np.argmax(t, axis=1)
        accuracy = np.sum(p == y) / float(x.shape[0])
        return accuracy
if __name__ == '__main__':


    train_dataset = dsets.MNIST(root='/ml/pymnist',  # 选择数据的根目录
                                train=True,  # 选择训练集
                                transform=None,  # 不考虑使用任何数据预处理
                                download=True)  # 从网络上download图片
    test_dataset = dsets.MNIST(root='/ml/pymnist',  # 选择数据的根目录
                               train=False,  # 选择测试集
                               transform=None,  # 不考虑使用任何数据预处理
                               download=True)  # 从网络上download图片
    x_train = train_dataset.data.numpy().reshape(-1,28*28)
    y_train_temp = train_dataset.targets.reshape(train_dataset.targets.shape[0],1)
    y_train = torch.zeros(y_train_temp.shape[0],10).scatter_(1,y_train_temp,1).numpy()
    x_test = test_dataset.data.numpy().reshape(-1,28*28)
    y_test_temp = train_dataset.targets.reshape(train_dataset.targets.shape[0], 1)
    y_test = torch.zeros(y_test_temp.shape[0], 10).scatter_(1, y_test_temp, 1).numpy()

    # 超参数
    iters_num = 600  # 适当设定循环的次数
    train_size = x_train.shape[0]

    batch_size = 100
    learning_rate = 0.001
    epoch = 5 #将所有数据集迭代的次数
    network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)



    for i in range(epoch):
        print('current epoch is :', i)
        for num in range(iters_num):
            batch_mask = np.random.choice(train_size, batch_size)
            x_batch = x_train[batch_mask]
            y_batch = y_train[batch_mask]

            grad = network.numerical_gradient(x_batch, y_batch)

            for key in ('W1', 'b1', 'W2', 'b2'):
                network.params[key] -= learning_rate * grad[key]

            loss = network.loss(x_batch, y_batch)
            if num % 100 == 0:
                print(loss)
    print(network.accuracy(x_test, y_test))

对于损失函数，激活函数，以及梯度下降的理解

举报

相关推荐

opencv数字识别神经网络

数据集神经网络神经网络模型人工智能

通俗易懂—卷积神经网络进行数字识别的过程

c++

使用神经网络识别手写数字

神经网络pytorch

前馈神经网络手写数字识别

paddle数据数组Python后端开发

【Python实战】——神经网络识别手写数字

服务器windows改行学it

离散Hopfield神经网络的联想记忆—数字识别

ide环境变量数字识别OpenStack云计算

测试开发 | 卷积神经网络（CNN）：图像识别的骨干

卷积神经网络池化卷积软件测试

莫烦pytorch学习笔记（八）——卷积神经网络（手写数字识别实现）

2d数据ide编程语言

卷积神经网络-奥特曼识别

深度学习人工智能服务器网络爬虫python安全

Keras深度学习（5）-卷积神经网络识别手写数字

深度学习kerascnn卷积神经网络
0 条评论