当前位置：移动技术网 > IT编程>开发语言>.net > 【深度学习】（二）神经网络：激活函数、MNIST

【深度学习】（二）神经网络：激活函数、MNIST

2020年07月12日 | 移动技术网IT编程 | 我要评论

感知机需要人为设定符合预期输入输出的权重。
神经网络可以自动地从数据中心学习到合适的参数。

质朴感知机：指单层网络，激活函数使用了阶跃函数的模型。
多层感知机：指神经网络，使用平滑的激活函数的多层网络。

激活函数

激活函数是将输入信号的总和转换为输出信号的函数。y = h(∑xi*wi)

阶跃函数

阶跃函数以阈值为界，一旦输入超过阈值，就切换输出。
感知机中流动的是0或1的二元信号。

import numpy as np
import matplotlib.pyplot as plt

'''
def step_function(x):
    return np.array(x>0, dtype=np.int)
'''

def step_function(x):
    y = x > 0 # [False True]
    return y.astype(np.int) # 通过指定期望类型转换NumPy数组

x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1) # 指定y轴范畴
plt.show()

在这里插入图片描述

sigmoid函数

sigmoid函数具有平滑性。
神经网络中流动的是连续的是数值信号。

def sigmoid(x):
    return 1 / (1 + np.exp(-x)) # e^（-x）

在这里插入图片描述

ReLU函数

ReLU（Rectified Linear Unit）函数在输入小于0是输出0 ，大于0时输出本身。

def relu(x):
    return np.maximum(0, x) # 取最大值

在这里插入图片描述

神经网络

求解机器学习问题的步骤分为：
“学习”：进行模型的学习
“推理”：用所学到的模型对未知的数据进行推理（分类）

多维数组的运算

import numpy as np
import matplotlib.pyplot as plt

A = np.array([1, 2, 3, 4]) # 一维数组
print(A) # [1 2 3 4]
print(np.ndim(A)) # 数组的位数。1
print(A.shape) # 返回一个元组，表示元素个数。(4,)

B = np.array([[2, 3], [4, 5]])
C = np.array([[1, 2], [6, 8]])
print(np.dot(B, C)) # 矩阵乘法。左行*右列

3层神经网络的实现：恒等函数

import numpy as np

def sigmoid(x): # 隐藏层激活函数
    return 1 / (1 + np.exp(-x)) # e^x

def identity_function(x): # 输出层激活函数：恒等函数，将输入按原样输出
    return x

def init_network(): # 进行权重和前置的初始化
    network = {} # 字典变量
    # 权重角标：后|先的神经元序号
    network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]]) # 第一层权重
    network['b1'] = np.array([[0.1, 0.2, 0.3]]) # 第一层偏置神经元的权重
    network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
    network['b2'] = np.array([0.1, 0.2])
    network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
    network['b3'] = np.array([0.1, 0.2])

    return network

def forword(network, x): # 封装输入信号转换为输出信号的过程
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1 # 第一个隐藏层
    z1 = sigmoid(a1) # 由激活函数转换为输出，作为第二层的输入
    a2 = np.dot(z1, W2) + b2
    z2= sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = identity_function(a3) # 输出

    return y

network = init_network()
x = np.array([1.0, 0.5]) # 输入
y = forword(network, x)
print(y) # [[0.31682708 0.69627909]]

输出层的设计：softmax函数

机器学习的问题分为：分类问题。回归问题（根据某个输入预测一个连续的数值）。
归回问题用恒等函数，分类问题用softmax函数。

softmax函数：指数运算会出现溢出问题，在进行运算时加上/减去某一个常数不会改变运算结果。

def softmax(a):
    c = np.max(a) # 取最大值作为常数
    exp_a = np.exp(a - c)  # 溢出对策
    sum_exp_a = np.sum(exp_a)
    y = exp_a/sum_exp_a

    return y

函数的输出总和为0，可以看作“概率”。
神经网络把输出值最大的神经元所对应的类别。
对于分类问题，输出层神经元数量一般设定为类别的数量。

手写数字识别（MNIST数据集）

MNIST手写数字图像集，由0到9的数字图像构成。先用训练图像进行学习，再用学习到的模型度量能在多大程度上对测试图像进行正确的分类。

从我学习的这本书，嫖了代码，可以下载MNIST数据集并将这些数据转换成NumPy数组进行处理。

mnist.py

# coding: utf-8
try:
    import urllib.request
except ImportError:
    raise ImportError('You should use Python 3.x')
import os.path
import gzip
import pickle
import os
import numpy as np


url_base = 'http://yann.lecun.com/exdb/mnist/'
key_file = {
    'train_img':'train-images-idx3-ubyte.gz',
    'train_label':'train-labels-idx1-ubyte.gz',
    'test_img':'t10k-images-idx3-ubyte.gz',
    'test_label':'t10k-labels-idx1-ubyte.gz'
}

dataset_dir = os.path.dirname(os.path.abspath(__file__))
save_file = dataset_dir + "/mnist.pkl"

train_num = 60000
test_num = 10000
img_dim = (1, 28, 28)
img_size = 784


def _download(file_name):
    file_path = dataset_dir + "/" + file_name
    
    if os.path.exists(file_path):
        return

    print("Downloading " + file_name + " ... ")
    urllib.request.urlretrieve(url_base + file_name, file_path)
    print("Done")
    
def download_mnist():
    for v in key_file.values():
       _download(v)
        
def _load_label(file_name):
    file_path = dataset_dir + "/" + file_name
    
    print("Converting " + file_name + " to NumPy Array ...")
    with gzip.open(file_path, 'rb') as f:
            labels = np.frombuffer(f.read(), np.uint8, offset=8)
    print("Done")
    
    return labels

def _load_img(file_name):
    file_path = dataset_dir + "/" + file_name
    
    print("Converting " + file_name + " to NumPy Array ...")    
    with gzip.open(file_path, 'rb') as f:
            data = np.frombuffer(f.read(), np.uint8, offset=16)
    data = data.reshape(-1, img_size)
    print("Done")
    
    return data
    
def _convert_numpy():
    dataset = {}
    dataset['train_img'] =  _load_img(key_file['train_img'])
    dataset['train_label'] = _load_label(key_file['train_label'])    
    dataset['test_img'] = _load_img(key_file['test_img'])
    dataset['test_label'] = _load_label(key_file['test_label'])
    
    return dataset

def init_mnist():
    download_mnist()
    dataset = _convert_numpy()
    print("Creating pickle file ...")
    with open(save_file, 'wb') as f:
        pickle.dump(dataset, f, -1)
    print("Done!")

def _change_one_hot_label(X):
    T = np.zeros((X.size, 10))
    for idx, row in enumerate(T):
        row[X[idx]] = 1
        
    return T
    

def load_mnist(normalize=True, flatten=True, one_hot_label=False):
    """读入MNIST数据集
    
    Parameters
    ----------
    normalize : 将图像的像素值正规化为0.0~1.0
    one_hot_label : 
        one_hot_label为True的情况下，标签作为one-hot数组返回
        one-hot数组是指[0,0,1,0,0,0,0,0,0,0]这样的数组
    flatten : 是否将图像展开为一维数组
    
    Returns
    -------
    (训练图像, 训练标签), (测试图像, 测试标签)
    """
    if not os.path.exists(save_file):
        init_mnist()
        
    with open(save_file, 'rb') as f:
        dataset = pickle.load(f)
    
    if normalize:
        for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].astype(np.float32)
            dataset[key] /= 255.0
            
    if one_hot_label:
        dataset['train_label'] = _change_one_hot_label(dataset['train_label'])
        dataset['test_label'] = _change_one_hot_label(dataset['test_label'])
    
    if not flatten:
         for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].reshape(-1, 1, 28, 28)

    return (dataset['train_img'], dataset['train_label']), (dataset['test_img'], dataset['test_label']) 


if __name__ == '__main__':
    init_mnist()

读入MNIST数据集

如果需要导入父目录的文件，需要增添搜索路径sys.path.append(os.pardir)

第一次调用load_mist函数的时候，自动下载MNIST数据集，也不知道我是网卡了还是怎么回事，反正这是数据集是不能直接下载成功的，一切报错都是因为下载不成功！
于是主动下载4个文件：
在这里插入图片描述
展示MNIST数据集

import sys, os
sys.path.append(os.pardir) # 为导入父目录中的文件而进行设定
from Mnist.mnist import load_mnist

# 读入数据集
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)

print(x_train.shape) # 训练图像。(60000, 784)
print(t_train.shape) # 训练标签。(60000,)
print(x_test.shape) # 测试图像。(10000, 784)
print(t_test.shape) # 测试标签。(10000,)

load_mnist函数：返回“（训练图像，训练标签），（测试图像，测试标签）”。
有3个参数：normalize是否输入图像正规化为0.0~1.0，False图像像素保持原来的0 ~ 255。flatten是否展开图像（变784个元素的一维数组），False图像为12828的三维数组。one_hot_label是否将标签保存会one_hot表示（只有一个1，其它全是0）。

Python具有pickle功能，即可以把程序运行中的对象保存为文件。如果加在保存过的pickle文件，可以立刻复原之前程序运行中的对象。

学习

import sys, os
sys.path.append(os.pardir) # 为导入父目录中的文件而进行设定
from Mnist.mnist import load_mnist
from PIL import Image # 图像的显示
import numpy as np

def img_show(img): # 显示图像
    pil_img = Image.fromarray(np.uint8(img)) # 把保存为NumPy数组的图像数据转换为PIL所用数据对象
    pil_img.show()

# 读入数据集。以一列一维NumPy数组的形式保存
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
img = x_train[0] # 选第一张训练图像
label = t_train[0] # 第一个训练标签
print(label) #

print(img.shape) # 5
img = img.reshape(28, 28) # 指定期望的形状更改NumPy数组。(784,)
print(img.shape) # (28, 28)

img_show(img)

在这里插入图片描述

推断处理

推断处理也叫向前传播。神经网络的输入层有784个神经元（图像大小28*28），输出层有10个神经元（0-9）。采用三层神经网络实现。
读取了保存在pickle文件samle_weight.pkl中的学习到的权重参数，文件中以字典变量的形式保存了权重和偏置参数。（这个文件也是下载的）

import sys, os
sys.path.append(os.pardir) # 为导入父目录中的文件而进行设定
from Mnist.mnist import load_mnist
import numpy as np
import pickle
from h import sigmoid
from h import softmax

# 获取数据
def get_data():
# 读入数据集。对一列一维NumPy数组进行预处理：正规化，使数据值在0.0~1.0
    (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=True, one_hot_label=False)
    return x_test, t_test

# 初始化神经网络。读入pickle文件中的学习参数
def init_network():
    with open("sample_weight.pkl", "rb") as f:
        network = pickle.load(f)

    return network

# 3层神经网络。推断处理也叫向前传播
def predict(network, x): # 封装输入信号转换为输出信号的过程
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1 # 第一个隐藏层
    z1 = sigmoid(a1) # 由激活函数转换为输出，作为第二层的输入
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = softmax(a3) # 输出

    return y

x, t = get_data()
network = init_network()

accuracy_cnt = 0
for i in range(len(x)):
    y = predict(network, x[i])
    p = np.argmax(y) # 获取最高的元素的索引
    if p == t[i]:
        accuracy_cnt += 1

print("Accuracy:" + str(float(accuracy_cnt)/len(x))) # Accuracy:0.9352

批处理

一张784像素的图片输出为10。
同时处理100张，100784->10010
这种打包式的输入数据成为批。

x, t = get_data()
network = init_network()

batch_size = 100 # 批数量
accuracy_cnt = 0
for i in range(0, len(x), batch_size):
    x_batch = x[i:i+batch_size] # 取出第i个到第i+batch_n中的数据
    y_batch = predict(network, x_batch) # 100*10 数据
    p = np.argmax(y_batch, axis=1) # 指定沿着第1维方向找到最大的元素的索引。返回100数据
    accuracy_cnt += np.sum(p == t[i:i+batch_size]) # 以批为单位进行比较，返回True的个数

print("Accuracy:" + str(float(accuracy_cnt)/len(x))) # Accuracy:0.9352

本文地址：https://blog.csdn.net/weixin_43931465/article/details/107244281

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

C#中的虚方法和抽象方法的运用

今天在云和学院学了很多，我这次只能先总结一下c#中的虚方法和抽象的运用。理论：虚方法：用virtual修饰的方法叫做虚方法虚方法可以在子类中通过over... [阅读全文]
如何使用VSCode发布博客到博客园

随着markdown格式笔记的流行,现在很多程序员都开始使用markdown来编辑自己的博客.然而,博客园的markdown格式编辑器使用体验真的一言难... [阅读全文]
EntityFramework 6 Tips

When working with Web applications, use a context instance per request. Inst... [阅读全文]
.Net 异常记录

工作上什么不顺的bug就记录在这吧。。。。。。 1，空异常会常常考虑到，但是这里容易报一个序列不包含任何元素异常，假如dt没有行。 dt.AsEnume... [阅读全文]
根据反射，动态调用websever

[WebMethod] public string index(string Action,string Message) { try { // 1. ... [阅读全文]
一秒扫雷

可以直接用CE进行雷总数修改，下面是通过C#直接修改雷总数内存地址 /// PROCESS_ALL_ACCESS -> (STANDARD_RIG... [阅读全文]
C#委托的价值，结合业务场景分析

1、业务背景技术为业务而生，技术为解决业务问题而存在，技术脱离业务就变得没有价值，我们在探讨某一个技术带来的价值时，都需要有一定的业务背景作为前提。我... [阅读全文]
关于个人总结的.net入门模型映射转换问题

关于个人总结的.net入门模型映射转换问题刚开始使用VS进行.net开发，虽然业务不是很复杂，自己在实践中还是遇... [阅读全文]
物联网综合服务平台——云计算平台

——参考自：国家出版基金项目《物联网与智能制造》张晶化学工业出版社总览Author：HYHDate：202... [阅读全文]
(精华)2020年7月21日 ASP.NET Core 容器伪属性注入

Controller 默认是不会通过自带容器来 Resolve&Activate 的，是通过MVC自身管... [阅读全文]