- 在线时间
- 1630 小时
- 最后登录
- 2024-1-29
- 注册时间
- 2017-5-16
- 听众数
- 82
- 收听数
- 1
- 能力
- 120 分
- 体力
- 565365 点
- 威望
- 12 点
- 阅读权限
- 255
- 积分
- 174832
- 相册
- 1
- 日志
- 0
- 记录
- 0
- 帖子
- 5313
- 主题
- 5273
- 精华
- 3
- 分享
- 0
- 好友
- 163
TA的每日心情 | 开心 2021-8-11 17:59 |
|---|
签到天数: 17 天 [LV.4]偶尔看看III 网络挑战赛参赛者 网络挑战赛参赛者 - 自我介绍
- 本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。
 群组: 2018美赛大象算法课程 群组: 2018美赛护航培训课程 群组: 2019年 数学中国站长建 群组: 2019年数据分析师课程 群组: 2018年大象老师国赛优 |
! T2 X4 J" W+ d+ x( m
Python深度学习之初窥神经网络
& G9 R3 m* A# r" r. y7 }: |2 f本文为 第2章 开始之前:神经网络背后的数学 (Chapter 2. Before we begin: the mathematical building blocks of neural networks) 的笔记整合。
# e( J) q% U- m( X& j! }4 n+ {) X3 Y7 ?' ]% o( y- f
本文目录:
4 O: C0 r, h% m9 D& k; I; `/ W- w" ^& r2 G3 T! F
文章目录
4 m G0 A4 R+ l1 k4 e
& p m& m" v; l$ I7 cDeep Learning with Python+ z X9 L% ?4 z; N0 q2 V, j
初窥神经网络
/ |9 w& }& {- F. b5 H导入MNIST数据集
4 e2 U" Y X" ^' N+ F- w4 J网络构建
3 f, x* n, W: J9 S编译
* y, \: p9 h( e( S1 G; K* U7 Z, @0 S预处理 G+ a; @' I; W) c6 }
图形处理# R$ @" K: Q7 w4 x" R( d
标签处理& ~5 D# l/ q' Y
训练网络
' x/ ~; }3 k( L, m神经网络的数据表示# t. O* S* I% t' `8 [' ]5 W k
认识张量+ S1 |! J; }6 c/ C/ T
标量 (0D Tensors)- `0 e( j6 a( m+ U- n
向量 (1D Tensors)
r* ]8 W5 X& a- {1 D矩阵 (2D Tensors)
: N2 ^! ?" ]) ~- S高阶张量' V, a. j# _1 a* ?
张量的三要素
U9 f; G+ H/ ?8 B+ Z/ V7 C7 nNumpy张量操作, }, ]& J; g' o- a/ d
张量切片:* f( R/ l w$ R' F
数据批量. r& K M( b; F! G, f+ `4 z5 \
常见数据张量表示. e4 D7 H: Z6 {' M: @+ Y
神经网络的“齿轮”: 张量运算. Q( ^. O2 }0 |' H' P# x
逐元素操作(Element-wise). ~0 C. j$ o0 l( V. F
广播(Broadcasting)/ \7 t$ x% M7 q3 d1 M! H
张量点积(dot)
d l# m! I2 z- k2 i% X张量变形(reshaping). U, H M+ ~! V) W
神经网络的“引擎”: 基于梯度的优化5 _! ~5 v' d% r/ A1 M
导数(derivative)
6 |8 r6 A8 N' i: x/ M梯度(gradient)
7 J9 Q& S6 g+ R+ v& v随机梯度下降(Stochastic gradient descent)0 h7 j( U2 G: i# }/ _; r/ D
反向传播算法:链式求导! u( W/ Q1 y9 q- ^: ?
本文由 CDFMLR 原创,收录于个人主页 https://clownote.github.io。
* X3 j; z% \, W- x/ D! H( |/ O0 _4 X" O7 J2 l6 ~
初窥神经网络/ D' Z$ _0 |3 t( X8 T3 J! z9 W( N! ]
T( a# T/ w2 v
学编程语言从 “Hello World” 开始,学 Deep learning 从 MINST 开始。+ W9 h s7 k* O+ T! }6 q+ O# v( L
& X7 a; M" L: g0 q. f$ F6 rMNIST 用来训练手写数字识别, 它包含 28x28 的灰度手写图片,以及每张图片对应的标签(0~9的值)。
1 D( ~+ |# [+ [: K+ \* f7 \- q
7 V! K i8 Z2 ?# }# x9 Y# j6 O3 ^# X导入MNIST数据集; p2 y! g8 Q6 r5 l9 }
6 V! B1 r) G; ?! {* |& i# Loading the MNIST dataset in Keras9 L% h/ n* F* F( T
from tensorflow.keras.datasets import mnist
- ~- n# I. H$ M& \. Q7 o(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
+ R# \8 m+ i1 `# D1. J, f, P0 ~6 z* j
2
% ^& w: f; J; R! b) B31 T" w: T9 ^- W1 C/ I) s
看一下训练集:1 @( l& n6 F% @# G; Q
; `* C/ A3 B9 h( fprint(train_images.shape)$ J3 B8 c" d/ W$ U
print(train_labels.shape)
; h* A8 a6 Q0 ktrain_labels4 h/ g# i+ n, r" T0 D0 U3 ~$ t9 E
1: k/ ?7 }; U# t9 u
2/ P" `! q8 W% L! S/ M( i5 g7 h
34 w6 L3 j- v' y% C5 s! i
输出:
# p) j. T; @; z5 n4 s% Y
1 O6 ~. |- |5 f8 c5 [( l, v" D2 d(60000, 28, 28)6 s4 G* n6 r. u0 D" d
(60000,)+ f( D$ b# _) @! K: k7 u
& v! k0 G9 {! d; parray([5, 0, 4, ..., 5, 6, 8], dtype=uint8)
8 H5 x6 s) c Q% n1
7 S2 p- b! Q" x- B" m+ e! S" o: U* m2" C- Q! l5 p; `+ a
3# s4 j8 y# c' g& c. k( q
4; W& b0 r3 C; L
这是测试集:
& e" d' }! K( B, z
6 o- S% [1 |8 Z+ E0 fprint(test_images.shape)
" o) F3 {$ @3 ?( Z8 Gprint(test_labels.shape)
1 l. r5 \" Z, @$ t% K/ E5 atest_labels
% ~8 C2 c8 m2 S7 _- t& D# w/ Y1
' N; B9 l5 w7 X. E3 U7 U! l- B5 H2& T) Q3 I# Y# l; U! I. A3 {
3
, n% [. l5 z/ b% f d8 k3 k输出:
$ N% z$ B0 ~) u9 @
' a* z$ F" W: l* _6 X(10000, 28, 28)
0 ^" ~$ l: @, C; X& s(10000,)4 A9 P! o2 O, R7 `
8 d2 H6 d! ^ f7 V: h' \array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)
; x+ R6 f" T: G# ]1
1 i# Z: Y4 D9 V! {/ e& o, \ z# H27 D& K; y J! I1 y1 r# n4 a
3
5 x$ Y+ _* a9 l( L/ M$ B& J0 |4
" I; l# ]9 `# x网络构建
8 u' o$ Q5 S, Q
) }( ]- Q+ F S$ m我们来构建一个用来学习 MNIST 集的神经网络:
/ o i) g1 x% {8 c: }. ~+ Y
" g) l. P: ^# D$ ofrom tensorflow.keras import models
) ^. p) s# J% F# L5 {from tensorflow.keras import layers/ @0 P# u6 \( i4 }0 A. }- C3 x
& \9 Q6 j( g4 Inetwork = models.Sequential()5 D3 K" e$ {- c* \0 a% X
network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))4 r1 n; _* [. v7 y# O& j6 W9 J
network.add(layers.Dense(10, activation='softmax'))# T$ U& K, B0 p$ R. f* ~7 A) z
1. }2 B( l5 C T5 _6 N& p
2/ j4 l2 ^# _' J6 n- P
32 o4 q: y8 d8 `7 c
4, J, H4 q7 F8 C
5
$ t+ e4 U( n7 b7 P$ n9 U) c6! G1 w _+ v# ~3 E
神经网络是一个个「层」组成的。( |; p- P0 K0 M9 O1 U+ q
一个「层」就像是一个“蒸馏过滤器”,它会“过滤”处理输入的数据,从里面“精炼”出需要的信息,然后传到下一层。
; Q* g4 \, R' k! q3 k
; H U5 O, X S9 e# o7 L这样一系列的「层」组合起来,像流水线一样对数据进行处理。
: Y" ^$ Y1 z _: u* v+ P层层扬弃,让被处理的数据,或者说“数据的表示”对我们最终希望的结果越来越“有用”。. f7 \: Q2 i6 @2 _8 B8 _' {& f) a
8 A2 t' ]" E% d( a
我们刚才这段代码构建的网络包含两个「Dense 层」,这么叫是因为它们是密集连接(densely connected)或者说是 全连接 的。
' k# w- D4 p) ~0 N$ @, `/ K. O1 O' N* i5 o: O- C
数据到了最后一层(第二层),是一个 10路 的 softmax 层。- X1 t* q6 Q; J, i
这个层输出的是一个数组,包含 10 个概率值(它们的和为1),这个输出「表示」的信息就对我们预测图片对应的数字相当有用了。+ \! J0 B* D# k; t/ Q
事实上这输出中的每一个概率值就分别代表输入图片属于10个数字(0~9)中的一个的概率!6 ]2 G7 ^, u8 E* h: m7 K h% m& z
. G/ [0 M" q* W编译+ ]7 d6 M3 \( _5 V
# v$ L0 c7 I+ S$ H
接下来,我们要 编译 这个网络,这个步骤需要给3个参数:1 K% F. k5 A% X! {% ~3 P
6 V- C. U2 h% L: X. X) j损失函数:评价你这网络表现的好不好的函数+ I7 @5 u% J3 N
优化器:怎么更新(优化)你这个网络
. O+ ^' F+ L7 ]/ V8 o2 ?1 g2 Q) {训练和测试过程中需要监控的指标,比如这个例子里,我们只关心一个指标 —— 预测的精度
, `( Q# X2 t2 }; ynetwork.compile(loss="categorical_crossentropy",2 F" P* L+ H( `# u
optimizer='rmsprop',
- K4 [- h) P8 h& |2 X metrics=['accuracy'])
" t$ W$ e) w3 I- O" n+ n" T1# v/ U8 Z L0 A
29 K, h M! U( [# s i4 p
3
) N) S' E; V4 g: e1 a8 x预处理
. {! X3 s! S2 J% ~+ ~; c; L9 Q# n: `' W; m% z* R
图形处理% r* E5 Z" c+ k& V0 d
& V. ^7 e( Z/ T, }/ E/ o. W7 u我们还需要处理一下图形数据,把它变成我们的网络认识的样子。8 \5 A1 _. d8 J. T! X# ~; B
) {: o- e0 Z8 L5 |8 [MNIST 数据集里的图片是 28x28 的,每个值是属于 [0, 255] 的 uint8。5 M0 m% d0 g4 O- t* L7 f
而我们的神经网络想要的是 28x28 的在 [0, 1] 中的 float32。2 k4 J9 X$ D' J3 `, j
1 u' C9 a& {, x$ {7 J8 m
train_images = train_images.reshape((60000, 28 * 28))
/ Q1 B& I$ S; M ^( b4 ^train_images = train_images.astype('float32') / 255, h+ i1 s3 Q1 D- U: X- ~5 z
; C/ C1 w: O9 d) F4 K
test_images = test_images.reshape((10000, 28 * 28)); z n. u9 R$ }- p W
test_images = test_images.astype('float32') / 255/ ?6 g, `0 L8 D# C' ~' H! r
1
) v5 [8 P$ E! x; v/ a2+ L$ v9 x" b' n
3
5 @) ]9 ~5 t1 L4 U6 z4
/ n; E9 Q: t! t5 w, X5
( F& W( X$ z( m% O( L标签处理
* e9 f+ ?, D4 l' ?" d
* u0 Q& m2 a) n% f) G& ^同样,标签也是需要处理一下的。
/ X1 V& u& W$ u. T; i
* e, G- J$ |. @5 M1 F) v0 A6 ^$ i1 Afrom tensorflow.keras.utils import to_categorical( r8 ^4 D" a/ o- p: o, F
! O! o( m3 w: y! ?3 {1 C$ J
train_labels = to_categorical(train_labels)0 J* i- g) Q( q
test_labels = to_categorical(test_labels)
# s" H$ M; m/ q) z% S) b: K" c( P1
% }, y& h- y2 R& G5 q2 J. g29 A' A- \( |( C/ |
3$ Y7 H2 \; [2 P( N" ]+ O' E
46 k7 v" |% \) F: i. _5 @
训练网络
# t& I3 T" V" H" b' R" i# A5 E) @2 o" u; O- w$ K
network.fit(train_images, train_labels, epochs=5, batch_size=128) j5 S2 W$ b# z3 {7 ^7 }- y
1
2 ~; u# I/ c( m- c0 c输出:: a8 _4 }8 L) @0 N. D' b3 {% {6 A
. ^( F# M. o, a7 }5 s) t8 WTrain on 60000 samples
1 l- n! ] n. k( ^Epoch 1/5; L' e7 T, \/ w' s# L4 F
60000/60000 [==============================] - 3s 49us/sample - loss: 0.2549 - accuracy: 0.9254
4 w) v" L( u) L- KEpoch 2/5; [6 L3 n% i) n" u
60000/60000 [==============================] - 2s 38us/sample - loss: 0.1025 - accuracy: 0.96934 x6 B* U$ E. v! S4 V' o) i1 w
Epoch 3/56 O3 V. e. P$ R
60000/60000 [==============================] - 2s 35us/sample - loss: 0.0676 - accuracy: 0.9800
. c! q5 W0 W4 V. v' Z0 i4 \4 y kEpoch 4/53 v" D( c" r" Z9 E" H# h
60000/60000 [==============================] - 2s 37us/sample - loss: 0.0491 - accuracy: 0.9848
, ~8 ~# s7 g: v! EEpoch 5/5; \6 _( J& A9 w X `
60000/60000 [==============================] - 2s 42us/sample - loss: 0.0369 - accuracy: 0.9888
, w3 G$ B0 R F+ T S, C& v2 P% o( u; V {. k+ g
<tensorflow.python.keras.callbacks.History at 0x13a7892d0>, I$ Z: H. k( x) ?/ f1 w7 b
1) B1 w+ a( W. l$ H w$ Y2 f
2
0 w2 t, V0 Z0 y3 `& N36 M2 t5 ?) c3 D" L( x; x
4$ z& P0 B" T" y
5
. f4 q% L& B8 Y, f2 {. A, @: f6: M7 i0 o: c7 y) d+ ?# b9 d! |
7
$ _. q" ?) G5 M+ S# `$ w8 m4 S( A% E2 q7 M' V* @
9, M+ \' ?1 ?. u4 m$ Q$ l& p q2 T
106 s( \: ~4 C) K" J4 w
110 O1 m% n9 r- _% v" T
12
1 S0 d) ^; r5 z9 [/ N13
^! Z' k- ?9 b/ ~$ l可以看到,训练很快,一会儿就对训练集有 98%+ 的精度了。
& ~% v" k5 j8 z! d, L* H7 H5 U7 A' W5 q; A! U+ X) R) x2 w7 m
再用测试集去试试:- K1 g" A3 ^& }' h/ r
6 K' W; O- b3 o' L( g
test_loss, test_acc = network.evaluate(test_images, test_labels, verbose=2) # verbose=2 to avoid a looooong progress bar that fills the screen with '='. https://github.com/tensorflow/tensorflow/issues/322860 h% t* B+ T8 d, w
print('test_acc:', test_acc)
# Y/ i- Z* F M. Z! ]! N& E6 u1 _11 b' R$ t) [3 O
2
. B2 p: t6 Z; C C输出:# B6 n# i1 O# Q2 _4 b, p
4 _* ^4 t9 e2 B4 `% d
10000/1 - 0s - loss: 0.0362 - accuracy: 0.9789& f7 }5 T! H' \- v/ J0 X
test_acc: 0.9789 }& S2 r" Q+ O4 j3 i( d
1- c3 H5 @& R* C: z0 ] ?: [
2" [: y" F5 v0 G4 }# Z) e
我们训练好的网络在测试集下的表现并没有之前在训练集中那么好,这是「过拟合」的锅。+ W# x. r9 O" R( H' K
( s+ D- h9 O" x; D4 L3 a神经网络的数据表示
" U# Q' @+ T X5 D6 q* [0 G! w; W) q
Tensor,张量,任意维的数组(我的意思是编程的那种数组)。矩阵是二维的张量。
a" |# z' @( ]& q0 f4 y" ?' Q: W0 j) Y& ?% {) u; ]" P' J
我们常把「张量的维度」说成「轴」。% u2 t4 \/ \- f& \* ^! P; k
" g. o! h6 z8 U# X; S
认识张量! f. \1 m6 k4 b! _: F1 ^+ Y
9 d5 o: m# {9 o6 n% [
标量 (0D Tensors)
- @# z4 D- d9 q0 E1 e5 z4 k5 v( B4 s1 K
Scalars,标量是 0 维的张量(0个轴),包含一个数。% m8 K2 @0 B2 d
8 Q4 l* P* U8 ?" ^1 K标量在 numpy 中可以用 float32 或 float64 表示。5 @" A5 S; o$ T( O7 Z
* ]7 E( b$ a4 J, f' c
import numpy as np, k, j, y4 ?; g2 c
- m: m- a" I; C( O. j. j( I9 I
x = np.array(12)
& b/ H$ [* I" w. A xx
% u7 j4 T* M6 x( J1
& k% B/ o0 {6 }" f: ?2
% L6 t& x+ i; p3 B: k" {3 d3
9 v$ C8 v! s4 S; y4
4 s: @1 j' Z; `; \5 ?+ r! G输出:
( {' c8 s5 U1 a, C4 }1 U
( x% v" Z" A* d5 Qarray(12)
. Y9 u$ j9 y. Y: g! e1
N) |2 K; K" qx.ndim # 轴数(维数)& @( Q% |4 Z+ _: P2 W3 v5 w
1( n; j- v- a) j* h& R% [
输出:
9 M2 A$ O n) K9 D L5 N6 Q. d: j& z$ S* K: D7 m" {( e
1
- k$ a3 ^8 O6 O8 G- L/ ?0 j8 _: W5 v16 d8 {, ?$ ~. f& R$ a0 w
向量 (1D Tensors)
! I4 A5 q$ X8 F) n
- V6 r \7 r7 l" sVectors,向量是 1 维张量(有1个轴),包含一列标量(就是搞个array装标量)。& }8 V& b( \* |/ H9 a& I- B
& _; d2 I1 `' O$ ^: X2 z* O0 N( s1 `
x = np.array([1, 2, 3, 4, 5])
8 ]* g& M# c0 p- tx9 g9 J/ b ]2 v& N% b; w- E
1
2 A& l7 u6 u Z8 u: _- C/ n) y2
; d! m+ Y- g3 p! Z% A( b输出:
4 q- r# t) g- G+ r* A6 t5 F8 C8 u+ Z& H K2 n3 Z0 ]
array([1, 2, 3, 4, 5])
/ |$ N( {- s3 p13 k. ^# v I* h8 @3 Q( w; Y. @
x.ndim
& n9 s1 y, q9 Y3 X) n1. W: R6 S( E) x% [# {
输出:$ Z7 a- Q; Y D% ^0 _( L
& ~' S4 E! \% a* W r, F; x
13 D. H5 p+ Z |9 A8 p% K9 F/ l
18 I7 B$ M) N7 V7 F' y' N% L/ I' l
我们把这样有5个元素的向量叫做“5维向量”。
4 C% N; h$ t4 O7 h2 Q但注意5D向量可不是5D张量!. r# k' M. r0 v$ i" p
" C: i: {( S3 {# t4 U, X0 [
5D向量:只有1个轴,在这个轴上有5个维度。
& Q1 f) d/ H3 d5D张量:有5个轴,在每个轴上可以有任意维度。
9 W% o4 p) l3 Q; E这个就很迷,这“维度”有的时候是指轴数,有的时候是指轴上的元素个数。
# G7 N( }6 a1 |! P4 ^& H b- Q& u9 {* ` ~2 b! R
所以,我们最好换种说法,用「阶」来表示轴数,说 5阶张量。! G$ R' e# P" ?+ s1 D
) m, N( g, _; ^& u& r% g/ b
矩阵 (2D Tensors)6 |" A" u( w& q. |; k
4 n2 [* t1 x1 g8 n. gMatrices,矩阵是 2 阶张量(2个轴,就是我们说的「行」和「列」),包含一列向量(就是搞个array装向量)。
- ]/ p- O6 k% P9 t6 _: f1 b) A( a$ @/ N W& v" F
x = np.array([[5, 78, 2, 34, 0],# B* S* q& x; h8 |4 L
[6, 79, 3, 35, 1],
$ s! J7 ^: k3 {4 r: F% m$ A [7, 80, 4, 36, 2]])/ U9 P0 d' Z3 c# e5 D& Y O7 y! M
x, K' E. r2 I% l. D/ z1 W
1
- ^6 ?7 R6 O2 _' l P$ _2
' H, ~( W1 x+ n6 X! H9 H( N3 {' ~' e3
8 S6 j' E6 j) k: m4 p( f1 w4
0 ?4 K8 r! f; f7 ^) [( D! d输出:
6 S: U/ k8 t, }4 h. @7 m1 P) d6 c8 v2 F t" [& @/ m9 }
array([[ 5, 78, 2, 34, 0],- v# X! s* U( S% d9 \4 F+ u
[ 6, 79, 3, 35, 1],, H% u& F! Q4 n2 U4 B
[ 7, 80, 4, 36, 2]])0 q6 v, }8 }' G5 F
1) o, b) x/ Y8 n/ N
25 U0 L3 a& d% H1 w5 i
3
- I- \+ t! {" X1 g+ b! K4 I- z9 ex.ndim
5 _3 k3 m( \2 u1( B0 y( B, I6 ?4 l0 w/ x
输出:
; z0 s5 m- E: v1 c
7 p( t( `/ b. E" q- ]# m27 Y( E* S2 g$ T/ t/ d
1
3 A ? f% Z# w# S% [0 G高阶张量
: [' }. W0 i% C; r+ K7 h
( m1 t6 L1 g$ p* D) @; Z你搞个装矩阵的 array 就得到了3阶张量。
' X S9 Q5 v% b/ u7 [# @0 Q; @
4 w1 W8 e0 i+ V7 f t3 D6 ~9 w- P再搞个装3阶张量的 array 就得到了4阶张量,依次类推,就有高阶张量了。4 B9 [$ ]3 x% \+ I) D7 R) O
; _, P5 T# K% W1 h! l/ S; U
x = np.array([[[5, 78, 2, 34, 0],
3 V r9 X, t3 P* V0 Q [6, 79, 3, 35, 1],' Z0 ?, J3 G5 r
[7, 80, 4, 36, 2]]," A4 e' Z$ G& J
[[5, 78, 2, 34, 0],
+ P, \3 ?1 E% b, e/ D- c [6, 79, 3, 35, 1],4 o8 ~* H- N3 d6 p& D, c7 j$ I
[7, 80, 4, 36, 2]],
$ ^7 U; X8 P" t0 C [[5, 78, 2, 34, 0],
5 l" [+ A' ^: X2 R9 K [6, 79, 3, 35, 1]," I8 r4 R0 @$ P @: N, K4 E t
[7, 80, 4, 36, 2]]]) e9 d' ?+ Z2 N. p; N
x.ndim
" n R4 G! V0 K: e! a1
6 \& l K2 n7 e; M7 {2
3 I5 Q6 U. H+ C# N6 u/ U; l3
* \ L2 ], m7 B+ i48 ]1 y6 h. L2 E9 z& x/ m* k: f
53 o. g. F& N7 {. p) k5 s
60 L0 }! E6 l+ T# e/ U
7
( I' C1 L0 L6 `6 n' K7 \8
: q0 X% @7 }/ Y& i4 y+ l- d8 a9! `& g/ a, @- g+ `! L8 g+ R
10; c; l5 Y" Y% A# ]$ C
输出:& X& O6 G0 ]; D6 `: k1 u. R4 ]
2 ?8 q9 K, \6 `6 T) M* u* r7 q/ v3/ R; @/ R1 P* }$ B9 a! L" a
1
- ]- V! d: t6 r: C! o6 b% ~. [! N深度学习里,我们一般就用0~4阶的张量。
- f, p( k# U- S' C; p9 h- [1 o" D- m8 p9 ]/ u# s' a {0 c. x
张量的三要素* O# c- q+ P2 U- B" D3 d6 C
8 h# e n- n. m* }
阶数(轴的个数):3,5,…4 @; L8 s1 T2 w) e% ~
形状(各轴维数):(2, 1, 3),(6, 5, 5, 3, 6),…
; s' u, r) W9 o4 c数据类型:float32,uint8,…
# s0 I3 M0 E) R/ g' @: f0 n% f% P0 @我们来看看 MNIST 里的张量数据:$ T# f9 |! [ n7 j( ]
6 {% {9 ~$ Z4 n ] z
from tensorflow.keras.datasets import mnist1 I5 d; F3 ?0 N5 h) K5 L
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()6 m, q0 b3 s4 }8 f; h
C1 r) ]% o: v$ o/ t8 F
print(train_images.ndim)9 v2 ]5 I* r( V& S
print(train_images.shape)+ x5 G8 G3 A% @( _2 Z
print(train_images.dtype): c ^6 a/ V7 i0 ]" I+ X, r
1
& q3 D3 [( z1 U; I/ _2
3 w% W3 x9 J9 Y3 M3# f( Q+ n7 v, w& C9 E; ]' w3 V
45 l' G" N/ h6 k" @6 T
5
, ~0 w& P/ X: T+ Y6
1 X( s5 B" ? M) k. B f8 x; l' M输出:
& }) H' n9 [" M
& C, w) f: [; f+ k% E$ I8 f! z3
8 Y- z$ k V. i- J(60000, 28, 28), h( z+ l: h% w, \/ P3 f+ ]8 t* I' `
uint8
& ^- [( s0 e0 B/ J/ `1 o! D1
7 w& Y, J8 E' P* `4 |, _' V' f2( \) X% h1 @! v* f
3& k2 a( A" J. j" Y# z
所以 train_images 是个8位无符号整数的3阶张量。
. G" N8 A R5 i$ G; T$ t; ~
0 K/ Y" n; S0 o$ y2 V4 m3 u$ D打印个里面的图片看看:% u! \0 Q, `/ Z5 h: S9 E6 X
) J# q1 M# [; |, P% y
digit = train_images[0]7 y. I A5 a0 z4 K
$ [/ G+ V9 m7 |& U
import matplotlib.pyplot as plt
7 N& b9 w* q# p: N% o& w7 D. V, _1 a: r/ B2 s" f
print("image:")
, ]( p! W6 |. K$ I5 uplt.imshow(digit, cmap=plt.cm.binary)
& q5 r6 u+ d, ?plt.show()& J" `7 ^- I) g* |7 L
print("label: ", train_labels[0])! W) r, n% T/ k, [: c! c
12 |$ n! O' Y4 G+ r: r% a9 S1 W1 S
2
: x8 f3 B0 Z! s3 y$ }31 ]3 B8 u# Y- E% K1 n( L( @
4# f5 o5 m6 D) |
5
; }7 d, \4 T8 N/ Z68 ?2 q8 l0 j; q! S5 M$ H( J3 \
7
2 T' O& ^6 B9 l8 p8
9 I! B9 D& C0 X输出:2 b: p5 ^6 ~) w5 f R% ^
1 h$ O. ]9 @$ ]' g
$ N& N$ y6 b- ~" r R9 e
. [- |- ^# s1 g( ?1 Wlabel: 5
' t2 ?$ a/ w- T( S0 |1# s R ^: P- I
Numpy张量操作3 B( p# T7 J5 c' d, ]
X# N3 P& u7 S! {, N k. _
张量切片:7 q9 Z+ f0 {. \9 j0 \
+ S1 L7 L0 y. o! S- J. N) X
my_slice = train_images[10:100]
8 h* H$ }9 P7 A% k% a9 _print(my_slice.shape)& e5 s& G/ t5 I6 t1 f
1. o! }" s" V( b
2
- ?! A- V( K* Y. y$ b$ l输出: V3 \4 L: J) a$ d0 l0 i/ T
+ y8 S5 J! g; z$ p- Z1 o# `3 N9 T& {(90, 28, 28)0 j3 L1 j. f! `! x
1# j/ b' h: w7 e4 Z1 Q: c, _% A
等价于:( Q4 ^1 S8 `; y/ L2 Z
' m+ N1 N q4 P% i3 `, `my_slice = train_images[10:100, :, :]
" F4 j. W9 t- A! b( tprint(my_slice.shape)
8 S; r) r( I) x3 b+ J; [12 j( N/ j; J9 ~( D5 R) b5 Y
21 t E/ d. o. `6 K+ P/ ~
输出:
0 x3 M: i2 Z B$ R+ d. G4 M
/ N K& w- m/ R, _( y; a# H1 I(90, 28, 28)
" D" @7 v2 X& p7 I1% Z- i5 m0 R+ N, r4 L
也等价于6 k+ G! n( T% Z
; E7 x, ~+ P. L4 I( t
my_slice = train_images[10:100, 0:28, 0:28]& u0 Q$ C' e0 i1 X
print(my_slice.shape)) ?$ u! w* M! ]; Q. s
1
# @3 |, `# k: K3 a8 O2" d/ `5 R% c2 P
输出:
/ I9 h- y4 H, G/ L" w" S& c' b- M
$ d& ]& B+ [) J0 Z2 R# E(90, 28, 28)) i2 a7 P! C$ S9 v. a0 ~
11 A' ~6 Z: C& T/ x% W m" n+ K
选出 右下角 14x14 的:. m0 ^, g5 c+ V8 J/ ^
& x6 [7 L# P" T; X7 x9 _) Imy_slice = train_images[:, 14:, 14:]
4 c5 {& \! H2 d+ a( S/ p6 Uplt.imshow(my_slice[0], cmap=plt.cm.binary)
0 l0 m+ p% N7 m6 H8 mplt.show()6 j8 E) f, U7 N' L" ~" w
1
5 n8 d5 V) B \' b2 \" n2
( s+ T( n4 c$ ], x3
J8 J: y8 E; `3 A7 N( x5 Q: f8 [+ f输出:3 M+ r3 |% m9 V. O! W. \2 {7 {
" j9 o: g$ G! \9 g% a' c( |; y9 M' N1 @6 b0 U# O
. F# ^/ g- G+ m7 _: n2 d
选出 中心处 14x14 的:
. K5 b7 v& Z4 `8 ?2 N; v& {
$ M2 r1 y2 B* _my_slice = train_images[:, 7:-7, 7:-7]) m6 v: Z. m0 u) S |, f: N, X
plt.imshow(my_slice[0], cmap=plt.cm.binary)
T0 v0 R2 |4 I2 S6 b" @% yplt.show()$ Y2 |; c6 H% f5 s& s8 ~. r
1
3 z6 C) i8 G# V4 F+ R7 N; U26 i2 f K$ ?; B# [" g- @' t! ~
3
& m8 n4 U0 \# n7 T; v输出:; s* i- c; y& g# Q( L5 h
4 D* E( y/ w7 g g# c
& @( A4 N+ A9 z: o! f ]8 A- ]+ K/ E$ l4 R c, n# J- L* `4 D. `% M
数据批量
: Y/ S, f- C* o/ e- @& V* V7 n$ T! w" |# m7 o; @
深度学习的数据里,一般第一个轴(index=0)叫做「样本轴」(或者说「样本维度」)。
2 ~2 h G1 S p( y3 j: h
$ t1 Z6 ^& }& T/ v z7 K b, I深度学习里,我们一般不会一次性处理整个数据集,我们一批一批地处理。1 c7 a) q4 ?) Q
( ]' h' U8 U9 g在 MNIST 中,我们的一个批量是 128 个数据:5 Y% _' h* Q/ P5 C6 S0 {
8 i- t* _- n" x& v7 y- a
# 第一批
& a5 u9 `3 A2 M; Pbatch = train_images[:128]
+ H( D* _# S9 V& i6 b# 第二批) L; c5 @, ]) v$ u; m
batch = train_images[128:256]: E6 A$ N. x! j
# 第n批
R o' f; W- @( I% P/ o( Sn = 124 {& R+ J/ t# K, p Z
batch = train_images[128 * n : 128 * (n+1)]( y* x7 g, I6 r; k
17 T# e- U# ?- Y7 E1 a7 s. z% D
25 l3 B: G5 c8 ^' O7 R) B
3
1 F2 p% J' o2 b( C1 _) d0 M2 b4
. J5 h7 |* C; i. S8 f5 {50 ^5 J9 d' w4 s0 P
6
4 t ], p( B! n C3 G7
: m8 ?9 c( H2 M# t) B/ I所以,在使用 batch 的时候,我们也把第一个轴叫做「批量轴」。
5 R% [3 v3 m& P# J7 A- ~6 u- S4 d5 y. J1 _
常见数据张量表示& n5 k" p# j9 V$ K# |- `1 u8 y
- s: R# C! r, `7 `
数据' X% v( C0 k+ q6 N
|
zan
|