感知机需要人为设定符合预期输入输出的权重。
神经网络可以自动地从数据中心学习到合适的参数。
质朴感知机：指单层网络，激活函数使用了阶跃函数的模型。
多层感知机：指神经网络，使用平滑的激活函数的多层网络。
激活函数
激活函数是将输入信号的总和转换为输出信号的函数。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数据集
展示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
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
