# 计算神经网络：数据读取与完成训练

train_img_path=r'C:UsersDellMNISTtrain-images.idx3-ubyte'

train_lab_path=r'C:UsersDellMNISTtrain-labels.idx1-ubyte'

test_img_path=r'C:UsersDellMNISTt10k-images.idx3-ubyte'

test_lab_path=r'C:UsersDellMNISTt10k-labels.idx1-ubyte'

import struct

train_num=50000

valid_num=10000

test_num=10000

with open(train_img_path,'rb') as f:

tmp_img=np.fromfile(f,dtype=np.uint8).reshape(-1,28*28)

train_img=tmp_img[:train_num] #前五万个数据是训练集

valid_img=tmp_img[train_num:] #第五万到第六万个数据是测试集

with open(test_img_path,'rb') as f:

test_img=np.fromfile(f,dtype=np.uint8).reshape(-1,28*28)

with open(train_lab_path,'rb') as f:

tmp_lab=np.fromfile(f,dtype=np.uint8)

train_lab=tmp_lab[:train_num]

valid_lab=tmp_lab[train_num:]

with open(test_lab_path,'rb') as f:

test_lab=np.fromfile(f,dtype=np.uint8)

reshape(-1,28*28) ：如果参数中存在-1，表示该参数由其他参数来决定.-1是将一维数组转换为二维的矩阵，并且第二个参数是表示每一行数的个数。

import matplotlib.pyplot as plt

def show_train(index):

plt.imshow(train_img[index].reshape(28,28),cmap='gray')

print('label:{}'.format(train_lab[index]))

def show_test(index):

plt.imshow(train_img[index].reshape(28,28),cmap='gray')

print('label:{}'.format(test_lab[index]))

def valid_train(index):

plt.imshow(valid_img[index].reshape(28,28),cmap='gray')

print('label:{}'.format(valid_lab[index]))

def tanh(x):

return np.tanh(x)

def softmax(x):

exp = np.exp(x-x.max())

return exp/exp.sum()

dimensions = [28*28,10]

activation = [tanh,softmax]

distribution=[

{

'b':[0,0]

},{

'b':[0,0],

'w':[-math.sqrt(6/(dimensions[0]+dimensions[1])),math.sqrt(6/(dimensions[0]+dimensions[1]))]

}]

# 初始化参数b

def init_parameters_b(layer):

dist = distribution[layer]['b']

return np.random.rand(dimensions[layer])*(dist[1]-dist[0])+dist[0]

# 初始化参数w

def init_parameters_w(layer):

dist = distribution[layer]['w']

return np.random.rand(dimensions[layer-1],dimensions[layer])*(dist[1]-dist[0])+dist[0]

# 初始化参数方法

def init_parameters():

parameter=[]

for i in range(len(distribution)):

layer_parameter={}

for j in distribution[i].keys():

if j=='b':

layer_parameter['b'] = init_parameters_b(i)

continue;

if j=='w':

layer_parameter['w'] = init_parameters_w(i)

continue

parameter.append(layer_parameter)

return parameter

# 预测函数

def predict(img,init_parameters):

l0_in = img+parameters[0]['b']

l0_out = activation[0](l0_in)

l1_in = np.dot(l0_out,parameters[1]['w'])+parameters[1]['b']

l1_out = activation[1](l1_in)

return l1_out

def d_softmax(data):

sm = softmax(data）

return np.diag(sm)-np.outer(sm,sm)

def d_tanh(data):

return 1/(np.cosh(data))**2

differential = {softmax:d_softmax,tanh:d_tanh}

differential = {softmax:d_softmax,tanh:d_tanh}

onehot = np.identity(dimensions[-1])

def sqr_loss(img,lab,parameters):

y_pred = predict(img,parameters)

y = onehot[lab]

diff = y-y_pred

return np.dot(diff,diff)

l0_in = img+parameters[0]['b']

l0_out = activation[0](l0_in)

l1_in = np.dot(l0_out,parameters[1]['w'])+parameters[1]['b']

l1_out = activation[1](l1_in)

diff = onehot[lab]-l1_out

act1 = np.dot(differential[activation[1]](l1_in),diff)

# 与上文优化d_tanh有关，将矩阵乘法化为数组乘以矩阵



grad_accu[key]/=batch_size。

def train_batch(current_batch,parameters):

for img_i in range(1,batch_size):

import copy

parameter_tmp = copy.deepcopy(parameters)

return parameter_tmp


def learn_self(learn_rate):

for i in range(train_num//batch_size):

if i%100 == 99:

print("running batch {}/{}".format(i+1,train_num//batch_size))

global parameters

parameters = combine_parameters(parameters,grad_tmp,learn_rate)

def valid_loss(parameters):

loss_accu = 0

for img_i in range(valid_num):

loss_accu+=sqr_loss(valid_img[img_i],valid_lab[img_i],parameters)

return loss_accu

def valid_accuracy(parameters):

correct = [predict(valid_img[img_i],parameters).argmax()==valid_lab[img_i] for img_i in range(valid_num) ]

print("validation accuracy:{}".format(correct.count(True)/len(correct)))

*注：此篇文章受B站up主大野喵渣的启发，并参考了其代码，感兴趣的同学可以去B站观看他关于神经网络的教学视频，以及到他的Github地址逛逛。

https://www.bilibili.com/video/av51197008

https://github.com/YQGong

|
10天前
|

24 3
|
20天前
|

31 1
|
21天前
|

75 0
|
13天前
|

【9月更文挑战第4天】在数字化时代，云计算已成为企业和个人存储和处理数据的首选方式。然而，随着云服务的普及，网络安全问题也日益凸显。本文将探讨云计算的基本原理，网络安全的重要性，以及如何在使用云服务时保护数据安全。我们将从云服务的基本概念出发，深入讨论网络安全的关键技术，最后提供一些实用的建议，帮助您在使用云服务时确保数据安全。
43 6
|
9天前
|

32 1
|
21天前
|

【8月更文挑战第28天】本文将深入探讨云原生技术的核心概念，包括容器化和微服务架构。我们将通过实际案例和代码示例，展示如何在云平台上实现高效的应用部署和管理。文章不仅提供理论知识，还包含实操指南，帮助开发者理解并应用这些前沿技术。 【8月更文挑战第28天】在数字化时代，网络安全和信息安全是保护个人和企业数据的前线防御。本文将探讨网络安全漏洞的成因、加密技术的应用以及提升安全意识的重要性。文章旨在通过分析网络安全的薄弱环节，介绍如何利用加密技术和提高用户警觉性来构建更为坚固的数据保护屏障。
61 2
|
6天前
|
SQL 安全 算法

15 0
|
14天前
|

22 0
|
18天前
|

【8月更文挑战第31天】在这篇文章中，我们将深入探讨云计算和网络安全之间的关系。我们将讨论云服务的安全性，以及如何通过实施强大的网络安全策略来保护您的数据。我们还将提供一些代码示例，以帮助您更好地理解这些概念。无论您是企业还是个人用户，这篇文章都将为您提供有关如何在云计算环境中保护自己的信息的宝贵见解。
22 0
|
18天前
|

【8月更文挑战第31天】在数字时代的浪潮中，数据成为了新的石油。了解如何从互联网的海洋中提取有价值的信息，是每个技术爱好者的必备技能。本文将引导你通过Python编程语言，利用其强大的库支持，一步步构建出你自己的网络爬虫。我们将探索网页请求、内容解析和数据存储等关键环节，并附上代码示例，让你轻松入门网络数据采集的世界。
76 0