目录
一、Numpy的数据类型
1、基本数据类型
注意str_和string_的区别：
str1 = np.array([1,2,3,4,5,6],dtype=np.str_)
string1 = np.array([1,2,3,4,5,6],dtype=np.string_)
print(str1,str1.dtype)
print(string1,string1.dtype)
输出：
['1' '2' '3' '4' '5' '6'] <U1
[b'1' b'2' b'3' b'4' b'5' b'6'] |S1
2.定义结构化数据
#首先创建结构化数据类型
dt = np.dtype([('age','i1')]) #age 类型的别名
print(dt)
#将数据类型应用于ndarray对象
students = np.array([(18),(19)],dtype=dt)
print(students,students.dtype,students.ndim)#输出students的值及其类型
输出：
[('age', 'i1')]
[(18,) (19,)] [('age', 'i1')] 1
示例：
描述一位老师的姓名、年龄、工资的特征，该结构化的数据包含以下字段：
str字段：name
int字段：age
float字段：salary
teacher = np.dtype([('name',np.str_,2),('age','i1'),('salary','f4')])
#输出结构化数据teacher
print(teacher)
#将其应用于ndarray对象
b = np.array([('w1',32,8537.50),('1h',28,7850.80)],dtype=teacher)
print(b)
输出：
[('name', '<U2'), ('age', 'i1'), ('salary', '<f4')]
[('w1', 32, 8537.5) ('1h', 28, 7850.8)]
取出教师的姓名和年龄信息：
print(b['name'])
print(b['age'])
输出：
['w1' '1h']
[32 28]
3.字符串类型长度的选择
创建字符串数组时，会取最大长度
#1.创建字符串数组时，会取最大长度
a = np.array(["a","ab","abc","我们","我们是谁","12345"],dtype=np.str_)
a
输出：
array(['a', 'ab', 'abc', '我们', '我们是谁', '12345'], dtype='<U5')
当修改内部元素时，也最多只能保存长度为5的字符串，超过的舍去
#.当修改内部元素时，也最多只能保存长度为5的字符串，超过的舍去
a[1]='123456'
a
输出：
array(['a', '12345', 'abc', '我们', '我们是谁', '12345'], dtype='<U5')
创建字符串数组，设置最大长度
#2.创建字符串数组，设置最大长度
a = np.array(["a","ab","abc","我们","我们是谁","12345"],dtype='U8')
a
输出：
array(['a', 'ab', 'abc', '我们', '我们是谁', '12345'], dtype='<U8')
改变元素的长度：
a[1]='123456789'
a
输出：
array(['a', '12345678', 'abc', '我们', '我们是谁', '12345'], dtype='<U8')
使其接受可变长度的字符，修改str为object数据类型即可
a = np.array(["a","ab","abc","我们","我们是谁","12345"],dtype='object')
a
输出：
array(['a', 'ab', 'abc', '我们', '我们是谁', '12345'], dtype=object)
改变元素长度：
a[1] = "lkkjjnmkkllkklmklmmklkkkk"
a
输出：
array(['a', 'lkkjjnmkkllkklmklmmklkkkk', 'abc', '我们', '我们是谁', '12345'],
dtype=object)
注意：
定长不灵活效率高，可变长度灵活效率低
二、操作文件loadtxt
loadtxt读取txt文本、csv文件
loadtxt(fname,dtype=<type 'float'>,comments='#',delimiter=None,
converters=None,skiprows=0,usecols=None,
unpack=False,ndmin=0,encoding='bytes')
参数：
fname:指定文件名称或字符串，支持压缩文件，包括gz、bz格式。
dtype:数据类型。默认float.
comments:字符串或字符串组成的列表。表示注释字符集开始的标志，默认为#。
delimiter：字符串。分隔符。
converters：字典。将指定列的数据转换为字典中对应的函数的浮点型数据。例如将控制转换为0，默认为空。
skiprows:跳过指定行数据。例如跳过前一行（可能是标题或注释），默认为0.
usecols:元组。用来指定要读取的数据的列，第一列为0.例如（1，3，5），默认为空。
unpack：布尔型。指定是否转置数组，如果为真则转置，默认为False.
ndmin:整数型。指定返回的数组中至少包含特定维度的数组。值域为0，1，2，默认为0.
encoding：编码，确认文件是gbk还是utf-8格式。
1.读取普通文件，可以不用设置分隔符（空格 制表符）：
data = np.loadtxt('data1.txt')
print(data,data.shape)
输出：
[[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[10. 11. 12. 13. 14. 15. 16. 17. 18. 19.]] (2, 10)
2.读取csv文件，设置分隔符，csv默认为,号
data = np.loadtxt('csv_test.csv',dtype=np.int32,delimiter=',')
print(data,data.shape)
输出：
[[ 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18]] (2, 9)
3.自定义数据类型读取
user_info = np.dtype([('name','U10'),('age','i1'),('gender','U1'),('height','i2')])
print(user_info)
#2.使用自定义的数据类型，读取数据
data = np.loadtxt('has_title.txt',dtype=user_info,skiprows=1,encoding='utf-8')
#注意以上参数中：a.设置类型 b.跳过第一行 c.编码
print(data)
输出：
[('name', '<U10'), ('age', 'i1'), ('gender', '<U1'), ('height', '<i2')]
[('小王', 21, '男', 170) ('老王', 50, '男', 180) ('小张', 25, '女', 165)
('小李', 21, '女', 170)]
计算平均年龄：
ages = data['age']
ages.mean()
读取年龄：
data = np.loadtxt('has_title.txt',dtype=int,skiprows=1,usecols=1,encoding='utf-8')#usecols=1：年龄是第一列的数据
data
输出：
array([21, 50, 25, 21])
计算女生的平均身高：
#计算女生的平均身高
user_info = np.dtype([('name','U10'),('age','i1'),('gender','U1'),('height','i2')])
data = np.loadtxt('has_title.txt',dtype=user_info,skiprows=1,encoding='utf-8')
isgirl = data['gender']=='女'
print(isgirl)
s_mean = np.mean(data['height'][isgirl])
'{:.2f}'.format(s_mean)
输出：
[False False True True]
'167.50'
读取指定的列：
user_info = np.dtype([('age','i1'),('height','i2')])
print(user_info)
data = np.loadtxt('has_title.csv',dtype=user_info,delimiter=',',skiprows=1,usecols=(1,3))
print(data)
输出：
[('age', 'i1'), ('height', '<i2')]
[(21, 170) (50, 180) (25, 165) (21, 170)]
三、随机函数
Numpy中的随机函数包含在random模块中，它能产生特定分布的随机数，如正态分布等。
numpy.random.rand(d0,d1,dn)
rand函数根据给定维度生成（0，1）之间的数据，包含0，不包含1.
dn表示每个维度
返回值为指定维度的array
创建4行2列的随机数据np.random.rand(4,2)
输出：
array([[0.84981436, 0.34008793],
[0.34676191, 0.53849959],
[0.35088206, 0.43358875],
[0.11094047, 0.58679883]])
创建2块2行3列的数据：np.random.rand(2,2,3)
输出：
array([[[0.17509191, 0.93687564, 0.89737946],
[0.4692661 , 0.74754379, 0.96843956]],
[[0.28007249, 0.58170105, 0.44656359],
[0.42028648, 0.29630363, 0.02719117]]])
numpy.random.randn(d0,d1,dn)
randn函数返回一个或一组样本，具有标准正态分布
dn表示每个维度
返回值为指定维度的array
示例：
from matplotlib import pyplot as plt
a = np.random.randn(10000)
print(a)
#直方图
plt.hist(a)
输出：
[-0.29296883 -0.22103483 0.50298164 ... -0.46302512 0.23561028
numpy.random.randint()
numpy.random.randint(low,high=None,size=None,dtype='1)
返回随机整数，返回区间为[low,hidh),包含low,不包含high
参数：low为最小值，high为最大值，size为数组维度大小，dtype为数据类型，默认的数据类型为np.int
high没有填写时，默认生成的随机数范围是[0,low)
返回[0,1)之间的整数，所以只有0np.random.randint(1,size=5)
输出：array([0, 0, 0, 0, 0])
返回1个[1,5)时间的随机整数np.random.randint(1,5)
输出：
4
返回 -5到5 之间不包括5 的2行2列数据np.random.randint(-5,5,size=(2,2))
输出：
array([[-1, 3],
[ 4, 4]])
numpy.random.sample
numpy.random.sample(size=None)
返回半开区间内的随机浮点数[0.0,1.0]np.random.sample((2,3))
输出：
array([[0.33268635, 0.69698999, 0.78680448],
[0.33824114, 0.16090616, 0.92463414]])
## 随机种子np.random.seed()
使用相同的seed()值，则每次生成的随机数都相同，使得随机数可以预测
但是，只调用seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数相同。
np.random.seed(1)
L1 = np.random.randn(3,3)
L2 = np.random.randn(3,3)
print(L1)
print('-'*50)
print(L2)
输出：
[[ 1.62434536 -0.61175641 -0.52817175]
[-1.07296862 0.86540763 -2.3015387 ]
[ 1.74481176 -0.7612069 0.3190391 ]]
--------------------------------------------------
[[-0.24937038 1.46210794 -2.06014071]
[-0.3224172 -0.38405435 1.13376944]
[-1.09989127 -0.17242821 -0.87785842]]
两次seed():
np.random.seed(1)
L1 = np.random.randn(3,3)
np.random.seed(1)
L2 = np.random.randn(3,3)
print(L1)
print('-'*50)
print(L2)
输出：
[[ 1.62434536 -0.61175641 -0.52817175]
[-1.07296862 0.86540763 -2.3015387 ]
[ 1.74481176 -0.7612069 0.3190391 ]]
--------------------------------------------------
[[ 1.62434536 -0.61175641 -0.52817175]
[-1.07296862 0.86540763 -2.3015387 ]
[ 1.74481176 -0.7612069 0.3190391 ]]
正态分布 numpy.random.normal()
numpy.random.normal(loc=0.0,scale=1.0,size=None)
作用：返回一个由size指定形状的数组，数组中的值服从
的正态分布
参数：
loc:float型或float型的类数组对象，指定均值
scale:float型或float型的类数组对象，指定标准差
size:int型或int型的元组，指定了数组的形状。如果不提供size,且loc和scale为标量，则返回一个服从该分布的随机数。
示例：
#标准正态分布，3行2列
a = np.random.normal(0,1,(3,2))
print(a)
print('-'*20)
#均值为1，标准差为3的正态分布
b = np.random.normal(1,3,(1000,))
#print(b)
plt.hist(b)
输出：
四、关于numpy的练习题：
1.导入鸢尾植物数据集
import numpy as np
from sklearn.datasets import load_iris
data = load_iris()
print(dir(data)) # 查看data所具有的属性或方法
print(data.DESCR) # 查看数据集的简介
print('**1'+'-'*100)
outfile = r'.\iris.data'
iris_data = np.loadtxt(outfile, dtype=object, delimiter=',')
print(iris_data)
2.求出鸢尾属植物萼片长度的平均值、中位数和标准差
sepallength = np.loadtxt(outfile, dtype=float, usecols=0,delimiter=',')
print(np.mean(sepallength))
print(np.mean(sepallength))
print(np.median(sepallength))
print(np.std(sepallength))
输出：
5.843333333333334
5.843333333333334
5.8
0.8253012917851409
3.创建一种标准化形式的鸢尾属植物萼片长度，其值正好介于0和1之间，使最小值为0，最大值为1
x = (sepallength - np.amin(sepallength))/np.ptp(sepallength)
print(x)
输出：
4.找到鸢尾属植物萼片长度的第5和第95百分位数（第一列)
print(np.percentile(sepallength,[5,95]))
输出：
[4.6 7.255]
5.把iris_data数据集的20个随机位置修改为np.nan的值
iris_data1 = np.loadtxt(outfile, dtype=object, delimiter=',')
i, j = iris_data1.shape
np.random.seed(20201130)
iris_data1[np.random.choice(i,size=20),np.random.choice(j,size=20)] = np.nan
print(iris_data1)
输出：
补充np.random.choice函数：
np.random.choice抽样函数def choice(a, size=None, replace=True, p=None):
参数：
a :待抽样的样本（一维数组或整数）
size: 输出大小，默认返回单个元素
replace : 抽样后的元素是否可重复，默认是
p: 每个样本点被抽样的概率，默认均匀抽样
举例：
a=[1,2,3,4,5]
p=[0.1,0.1,0.2,0.1,0.5]
np.random.choice(a,3,True,p)
输出：
array([4, 3, 5])
若输入a为整型，则表示从0到a-1中的整数样本进行抽样np.random.choice(5,3,True)
输出：
array([2, 2, 1])
第二个参数size不设置，则只返回单个元素np.random.choice(5)
输出：
3
6.在iris_data的sepallength种查找缺失值的个数和位置
iris_data2 = np.loadtxt(outfile,dtype=float,delimiter=',',usecols=[0,1,2,3])
i,j = iris_data2.shape
np.random.seed(202001130)
iris_data2[np.random.choice(i,size=20),np.random.choice(j,size=20)]=np.nan
sepallength2 = iris_data2[:,0]
print(sepallength2)
print(sum(np.isnan(sepallength2)))
print(np.where(np.isnan(sepallength2)))
输出：
[5.1 4.9 4.7 4.6 5. 5.4 4.6 5. 4.4 4.9 5.4 4.8 4.8 4.3 5.8 5.7 5.4 5.1
5.7 5.1 5.4 5.1 4.6 5.1 4.8 5. 5. 5.2 5.2 4.7 4.8 5.4 5.2 5.5 4.9 nan
5.5 4.9 nan 5.1 5. 4.5 4.4 5. 5.1 4.8 5.1 4.6 5.3 nan 7. 6.4 6.9 5.5
6.5 5.7 6.3 4.9 6.6 5.2 5. 5.9 6. 6.1 5.6 6.7 5.6 5.8 6.2 5.6 5.9 6.1
6.3 6.1 6.4 6.6 6.8 6.7 6. 5.7 5.5 5.5 5.8 6. 5.4 6. 6.7 6.3 nan 5.5
5.5 6.1 5.8 5. 5.6 5.7 5.7 6.2 5.1 5.7 6.3 5.8 7.1 nan 6.5 nan 4.9 7.3
6.7 7.2 6.5 6.4 6.8 5.7 5.8 6.4 6.5 7.7 7.7 6. 6.9 5.6 7.7 6.3 6.7 7.2
6.2 6.1 6.4 7.2 7.4 7.9 6.4 nan 6.1 7.7 6.3 6.4 6. 6.9 6.7 6.9 5.8 6.8
6.7 6.7 6.3 6.5 6.2 5.9]
7
(array([ 35, 38, 49, 88, 103, 105, 133], dtype=int64),)
7.筛选具有sepallength<5.0且petallength>1.5的iris_data行
iris_data3 = np.loadtxt(outfile, dtype=float,delimiter=',',usecols=[0,1,2,3])
sepallength3 = iris_data3[:,0]
petallength3 = iris_data3[:,2]
index = np.where(np.logical_and(sepallength3 < 5.0,petallength3 > 1.5))
print(iris_data3[index])
输出：
[[4.8 3.4 1.6 0.2]
[4.8 3.4 1.9 0.2]
[4.7 3.2 1.6 0.2]
[4.8 3.1 1.6 0.2]
[4.9 2.4 3.3 1. ]
[4.9 2.5 4.5 1.7]]
8.选择没有nan值的iris_data行
x = iris_data2[np.sum(np.isnan(iris_data2),axis=1) == 0]
print(x)
输出：
9.计算iris_data种sepallength和petallength之间的相关系数
x = np.corrcoef(sepallength3, petallength3)
print(x)
输出：
[[1. 0.87175416]
[0.87175416 1. ]]
10.找出iris_data是否有任何缺失值
x = np.isnan(iris_data3)
print(np.any(x))
输出：
False
11.将numpy数组中所有出现的nan替换为0
iris_data2 = np.loadtxt(outfile,dtype=float,delimiter=',',usecols=[0,1,2,3])
i,j = iris_data2.shape
np.random.seed(202001130)
iris_data2[np.random.choice(i,size=20),np.random.choice(j,size=20)]=np.nan
#print(iris_data2)
iris_data2[np.isnan(iris_data2)] = 0
print(iris_data2)
输出：
12.找出鸢尾属植物物种中的唯一值和唯一值出现的数量
iris_data4 = np.loadtxt(outfile,dtype=object,delimiter=',',usecols=4)
x = np.unique(iris_data4, return_counts=True)
print(x)
输出：
(array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype=object), array([50, 50, 50], dtype=int64))
#13.将iris_data的花瓣长度以分类变量的形式表示
petallength = iris_data3[:,2]
print(np.amin(petallength),np.amax(petallength))
inds = np.digitize(petallength,[0,3,5,7])
#print(inds)
label = {1:'small',2:'medium',3:'large'}
pl_label = [label[x] for x in inds]
print(pl_label)
输出：
1.0 6.9
['small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'small', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'large', 'medium', 'medium', 'medium', 'medium', 'medium', 'large', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'medium', 'large', 'large', 'large', 'large', 'large', 'large', 'medium', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'medium', 'large', 'medium', 'large', 'large', 'medium', 'medium', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'medium', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large', 'large']
14.在iris_data中创建一个新列，其中volume是（pipetallengthsepallength^2)/3
iris_data5 = np.loadtxt(outfile,dtype=object,delimiter=',')
sepallength5 = iris_data5[:,0].astype(float)
petallength5 = iris_data5[:,2].astype(float)
volume = (np.pi * petallength5 * sepallength5 **2)/3
volume = volume[:,np.newaxis]
iris_data5 = np.concatenate([iris_data5,volume],axis=1)
print(iris_data5)
输出：
np.newaxis:插入新维度，比如
a=np.array([1,2,3,4,5])
print("a的维度：",a.shape)
print ("a:",a)
aa=a[:,np.newaxis]
print("aa的维度:",aa.shape)
print ("aa:",aa)
输出：
a的维度： (5,)
a: [1 2 3 4 5]
aa的维度: (5, 1)
aa: [[1]
[2]
[3]
[4]
[5]]
15.随机抽取鸢尾属植物的种类，使得Iris-setosa的数量是Iris-versicolor和Iris-virginica数量的2倍
species = ['Iris-setosa','Iris-versicolor','Iris-virgincia']
np.random.seed(20201130)
species_out = np.random.choice(species, 50000, p=[0.5,0.25,0.25])
print(np.unique(species_out,return_counts=True))
输出：
(array(['Iris-setosa', 'Iris-versicolor', 'Iris-virgincia'], dtype='<U15'), array([24819, 12560, 12621], dtype=int64))
16.根据sepallength列对数据集进行排序
sepallength6 = iris_data[:,0]
index = np.argsort(sepallength6)
print(iris_data[index])
输出：
17.在鸢尾属植物数据集中找到最常见的花瓣长度值
petallength7 = iris_data[:,2]
length, counts = np.unique(petallength7,return_counts=True)
print(length,counts)
print("最大值的索引",np.argmax(counts))
print("\n")
print(length[np.argmax(counts)])
print(np.amax(counts))
输出：
petallength7 = iris_data[:,2]
length, counts = np.unique(petallength7,return_counts=True)
print(length,counts)
print("最大值的索引",np.argmax(counts))
print("\n")
print(length[np.argmax(counts)])
print(np.amax(counts))
#17.在鸢尾属植物数据集中找到最常见的花瓣长度值
petallength7 = iris_data[:,2]
length, counts = np.unique(petallength7,return_counts=True)
print(length,counts)
print("最大值的索引",np.argmax(counts))
print("\n")
print(length[np.argmax(counts)])
print(np.amax(counts))
['1' '1.1' '1.2' '1.3' '1.4' '1.5' '1.6' '1.7' '1.9' '3' '3.3' '3.5' '3.6'
'3.7' '3.8' '3.9' '4' '4.1' '4.2' '4.3' '4.4' '4.5' '4.6' '4.7' '4.8'
'4.9' '5' '5.1' '5.2' '5.3' '5.4' '5.5' '5.6' '5.7' '5.8' '5.9' '6' '6.1'
'6.3' '6.4' '6.6' '6.7' '6.9'] [ 1 1 2 7 12 14 7 4 2 1 2 2 1 1 1 3 5 3 4 2 4 8 3 5
4 5 4 8 2 2 2 3 6 3 3 2 2 3 1 1 1 2 1]
最大值的索引 5
1.5
14
18.在鸢尾花数据集的petalwidth中查找第一次出现大于1.0的位置
petalwidth = iris_data[:,3].astype(float)
index = np.where(petalwidth > 1.0)
#print(index)
print(index[0][0])
输出：
50
五、numpy实现简单神经网络
设计四层网络，实现MNIST手写数字识别：
输入的shape（batch_size,784）
权重矩阵W1的shape：（784，200）
得到中间层输出z1的shape:(batch_size,200)
使用sigmoid激活函数 a1 = sigmoid(z1)
权重矩阵W2的shape：（200，30）
得到中间层输出a2的shape:(batch_size,30)
使用sigmoid激活函数 a2 = sigmoid(z2)
权重矩阵W3的shape：（30，10）
得到输出层a3的shape:(batch_size,10)
使用sigmoid激活函数 a3 = sigmoid(z3)
对输出的结果a3求loss：使用均方误差np.sum((self.a3 - y)*(self.a3 - y)) / batch_size
（y为标签，并onehot编码）
反向传播求梯度
lr=0.4,batch_size=6,epoch=10
每循环一个epoch计算准确率
def sigmoid(x):
return 1 / (1 + np.exp(-x) )
def Dsigmoid(x):
return sigmoid(x)*(1-sigmoid(x))
#标签one-hot处理
def onehot(targets,num):
result = np.zeros((num,10))
for i in range(num):
result[i][targets[i]] = 1
return result
class NN(object):
#初始化
def __init__(self, l0, l1, l2, l3, batch_size=6):
self.W1 = np.random.randn(l0,l1) * 0.01
self.b1 = np.random.randn(l1) * 0.01
self.W2 = np.random.randn(l1,l2) * 0.01
self.b2 = np.random.randn(l2) * 0.01
self.W3 = np.random.randn(l2,l3) * 0.01
self.b3 = np.random.randn(l3) * 0.01
self.batch_size = batch_size
self.lr = 0.4
#前向传播
def forward(self, X, y):
self.X = X
self.z1 = np.dot(X, self.W1) + self.b1
self.a1 = sigmoid(self.z1)
self.z2 = np.dot(self.a1, self.W2) + self.b2
self.a2 = sigmoid(self.z2)
self.z3 = np.dot(self.a2, self.W3) + self.b3
self.a3 = sigmoid(self.z3)
loss = np.sum((self.a3 - y)*(self.a3 - y)) / 6
self.d3 = (self.a3 - y) * Dsigmoid(self.z3)
return loss, self.a3
#反向传播
def backward(self):
dW3 = np.dot(self.a2.T,self.d3) / self.batch_size
db3 = np.sum(self.d3,axis=0) / self.batch_size
d2 = np.dot(self.d3,self.W3.T) * Dsigmoid(self.z2)
dW2 = np.dot(self.a1.T,d2) / self.batch_size
db2 = np.sum(d2,axis=0) / self.batch_size
d1 = np.dot(d2,self.W2.T) * Dsigmoid(self.z1)
dW1 = np.dot(self.X.T,d1) /self.batch_size
db1 = np.sum(d1,axis=0) / self.batch_size
self.W3 -= self.lr * dW3
self.b3 -= self.lr * db3
self.W2 -= self.lr * dW2
self.b2 -= self.lr * db2
self.W1 -= self.lr * dW1
self.b1 -= self.lr * db1
def train():
nn = NN(784,200,30,10)
for epoch in range(10):
for i in range(0, 60000, nn.batch_size):
X = train_data.data[i:i+nn.batch_size]
Y = train_data.targets[i:i+nn.batch_size]
loss,_ = nn.forward(X,Y)
print("epoch:",epoch,"-",i,":","{:.3f}".format(loss))
nn.backward()
np.savez("data.npz",w1=nn.W1, b1=nn.b1, w2=nn.W2, b2=nn.b2, w3=nn.W3, b3=nn.b3)
def test():
r = np.load("data.npz")
nn = NN(784,200,30,10)
nn.W1 = r['w1']
nn.b1 = r['b1']
nn.W2 = r['w2']
nn.b2 = r['b2']
nn.W3 = r['w3']
nn.b3 = r['b3']
_,result = nn.forward(test_data.data,test_data.targets2)
result = np.argmax(result,axis=1)
precison = np.sum(result == test_data.targets) / 10000
print("precison:",precison)
if __name__ == '__main__':
#MNIST手写数据集
train_data = torchvision.datasets.MNIST(root = './mnist',train=True, download=True)
test_data = torchvision.datasets.MNIST(root='data/', train=False)
train_data.data = train_data.data.numpy() #[6000,28,28]
train_data.targets = train_data.targets.numpy() #[6000]
test_data.data = test_data.data.numpy() #[1000,28,28]
test_data.targets = test_data.targets.numpy() #[1000]
#输入向量处理
train_data.data = train_data.data.reshape(60000,28*28) / 255.
test_data.data = test_data.data.reshape(10000,28*28) / 255.
#标签one-hot处理
train_data.targets = onehot(train_data.targets,60000)#(60000,10)
test_data.targets2 = onehot(test_data.targets,10000)#用于前向传播
train()
test()
精度：
1125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
