- 在线时间
- 1630 小时
- 最后登录
- 2024-1-29
- 注册时间
- 2017-5-16
- 听众数
- 81
- 收听数
- 1
- 能力
- 120 分
- 体力
- 539958 点
- 威望
- 12 点
- 阅读权限
- 255
- 积分
- 167366
- 相册
- 1
- 日志
- 0
- 记录
- 0
- 帖子
- 5324
- 主题
- 5250
- 精华
- 18
- 分享
- 0
- 好友
- 163
TA的每日心情 | 开心 2021-8-11 17:59 |
---|
签到天数: 17 天 [LV.4]偶尔看看III 网络挑战赛参赛者 网络挑战赛参赛者 - 自我介绍
- 本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。
群组: 2018美赛大象算法课程 群组: 2018美赛护航培训课程 群组: 2019年 数学中国站长建 群组: 2019年数据分析师课程 群组: 2018年大象老师国赛优 |
+ }" W# ~5 ^5 H0 X5 l) D k2 A
Python深度学习之初窥神经网络
( g5 h0 T/ O6 b; L本文为 第2章 开始之前:神经网络背后的数学 (Chapter 2. Before we begin: the mathematical building blocks of neural networks) 的笔记整合。
% n; ?8 M* P, \: t% A7 n9 w( j5 l, p. r$ t# Z6 v% e& f
本文目录:
7 I) j2 l8 K. L) _! [: g$ }5 Z. D$ W8 e
文章目录
# B2 H1 k/ F- N; r8 \
) O. t" |; O9 ~' DDeep Learning with Python& m3 }" V1 u/ X* O
初窥神经网络
! u) y- s" T7 Y3 I, X! @导入MNIST数据集( f6 t/ f6 P1 Y5 @
网络构建
5 U9 E. T! V; Z6 |4 n# v* I; M编译
" v) W+ Y. N: n0 Q预处理; |# h0 I: n4 O% }
图形处理
& Z; D0 e0 m$ S% M$ L% u标签处理
0 P7 z6 S% a7 L. ]( M; ~0 q训练网络
- O5 L/ @& \; C. I3 [$ r神经网络的数据表示: Q8 @$ f6 t6 l0 N: v' V/ e
认识张量. B' Q0 E2 s) Q9 G) q
标量 (0D Tensors)
. n6 b; p3 r& S向量 (1D Tensors)
2 v4 Y9 h8 ?7 C& ?! f, o$ N; A矩阵 (2D Tensors)0 Q2 j! n9 I' Z$ y ^+ z+ P: U
高阶张量& p8 m) u7 z8 f" S1 g
张量的三要素
: z; @' o& d7 b9 B. l7 E0 `Numpy张量操作
0 e2 {7 c- h+ k* c9 c( b1 O1 l! B张量切片:4 j! v4 |0 }% O9 n
数据批量
& l8 Z7 b4 R" }' K9 d常见数据张量表示
, t5 ]& V6 K; ? G神经网络的“齿轮”: 张量运算
$ i+ o: U: Q+ v# @" F: t. E" K8 y逐元素操作(Element-wise). S z1 }( P3 n
广播(Broadcasting)6 x7 w+ L7 [. r
张量点积(dot); Y$ |( s) j+ Y2 A$ g! |4 e
张量变形(reshaping)+ b5 \, G" W$ b6 z% d+ J
神经网络的“引擎”: 基于梯度的优化
& _+ H |: r. C' O- w7 J1 x9 R导数(derivative)
# b( S& B3 N( {( S3 ^梯度(gradient)1 v1 _! L0 d8 i! }+ f4 f1 z7 E
随机梯度下降(Stochastic gradient descent)) a" V/ }- y3 L4 p8 y) v! w
反向传播算法:链式求导1 V! b; l2 o" B5 C4 H& i0 ?
本文由 CDFMLR 原创,收录于个人主页 https://clownote.github.io。
5 e7 V1 R# s* E. ?) L, O m1 X' }, K) G) D0 s- ]6 E& H, \
初窥神经网络
: Q2 u, [% u+ l7 g" L4 a, ^* W6 R' h' n. _& ?& S
学编程语言从 “Hello World” 开始,学 Deep learning 从 MINST 开始。/ A% Z. A0 a9 C; T' x9 E
1 c5 H5 G6 A% u: FMNIST 用来训练手写数字识别, 它包含 28x28 的灰度手写图片,以及每张图片对应的标签(0~9的值)。; w- s8 c9 q. m/ m, @0 H [1 G
: Q' e2 J" @) @, _6 }
导入MNIST数据集4 C+ U3 }1 z9 k4 D2 L
" t# Q5 M0 O) @( b- \# Loading the MNIST dataset in Keras9 z$ I8 T( D" S- a$ _
from tensorflow.keras.datasets import mnist0 g* ^* m0 \) V
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
' w @4 Q3 v" C! r& u* @7 a" ^8 X5 |: J1
' S4 }; T" l) w2
4 o" V* z7 n% J; M8 g' v, d" Z2 K) g3$ E7 |" ?" |' Q8 }: _% T
看一下训练集:( w, t1 {: D) C, `
0 r5 u- e' V, \+ e, y
print(train_images.shape)
. p' ~! b( ?1 Z& pprint(train_labels.shape). C* U7 S. H2 o* }& V
train_labels
' ~% g9 w" [" `1
i+ Z$ N. p+ D1 F( }8 i' [2, q' Z3 p5 W& Z: | c
3# m% |( r$ k6 w' x) r
输出:9 W5 f$ f7 f' {
. \9 T6 l& C5 y, {1 g, g' Y( {(60000, 28, 28)
2 V) I; I- d7 |(60000,)
r5 d1 |+ @' i9 e9 U1 i( m0 E5 Y; u, ~4 i8 E
array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)2 f q. I' |& l, ]& k$ Q
1
) T' H) E% e2 ^2! B: r9 W1 J/ t( d* L, H+ E: j$ m: A
39 I6 g7 @% ~! ~; P% q0 d% a
4
; N; h0 D0 C3 H% @ M3 ]' a7 F这是测试集:
( O, ^: q9 f. f7 i, C, n3 Q, p. L* Z5 R( Y
print(test_images.shape)) {( v# E$ t7 y9 x
print(test_labels.shape)" W5 C2 R' g5 H* g
test_labels
% J E" ?( G5 j$ u. l( G1
& k/ z) r- V; N2 _: O$ { P0 t0 Q2
4 v$ j0 g, s8 V* b- f3( H6 A4 c, }% h
输出:7 J) m9 e3 ?# z& y4 ]9 t2 X. w" u
1 O) ^4 Q( t% C3 c- c j: F
(10000, 28, 28)0 x1 w0 n( D; l2 Y8 h- I
(10000,)
4 A+ H. @2 J& f6 P7 D/ `, K! `, n9 K/ e5 S$ B3 m4 {% U
array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)
D+ S, \2 s; u6 R) o9 a5 H16 j, |, N& K( o5 |8 K: V, T) r
2; o# X( z* A! M+ L( l- G
3/ D9 a/ t+ m* S+ R4 l3 G
45 s# \) }- n `+ t1 f' {
网络构建
. _+ e. M4 E* z6 q" s& r; s" u
/ f/ C6 V# q e4 K) u; r* X我们来构建一个用来学习 MNIST 集的神经网络:) T8 y( g4 j7 A% P- @5 R3 b
+ D& h8 `/ i/ H: }
from tensorflow.keras import models
8 F* ^( R2 n, \$ I$ n/ \from tensorflow.keras import layers
1 W! A3 s, q$ V4 x; G* {* B% I( e7 N/ r4 i3 c" z- X2 U9 C# d, v
network = models.Sequential()
# I" E3 l. P F: [$ W& tnetwork.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))
9 Q2 y: I: }+ v5 f7 k( `8 qnetwork.add(layers.Dense(10, activation='softmax'))/ X" c1 [8 @& f! [2 M4 q$ Z3 x
1
: W" S6 y; W4 ^" G) _; |2
& D: M, Y! [+ N. G32 e, W' }. k, |
4" d$ ^/ M5 p$ S2 P. G( n$ w' J8 B8 d* e
5: X$ g9 R' b. I4 b8 U- p/ F; H
67 ?3 C* }# u9 l# @: ?
神经网络是一个个「层」组成的。% `1 Y: Y* {. O' I! v8 J
一个「层」就像是一个“蒸馏过滤器”,它会“过滤”处理输入的数据,从里面“精炼”出需要的信息,然后传到下一层。3 I& E; e3 w) p. Z% Z6 f0 K
- i2 b3 f* M* F& m8 X* @这样一系列的「层」组合起来,像流水线一样对数据进行处理。0 V% }3 T- N" f- I/ k6 W0 f
层层扬弃,让被处理的数据,或者说“数据的表示”对我们最终希望的结果越来越“有用”。
" g5 s' z% m1 j, y% b% E" e$ {! h4 Z: X% n' p/ ^, f
我们刚才这段代码构建的网络包含两个「Dense 层」,这么叫是因为它们是密集连接(densely connected)或者说是 全连接 的。0 k4 l4 I8 _: b% P1 j
) w, i9 ]* A: _; G. ~; c+ x, i P数据到了最后一层(第二层),是一个 10路 的 softmax 层。
3 z6 X8 }. c z* I. ]这个层输出的是一个数组,包含 10 个概率值(它们的和为1),这个输出「表示」的信息就对我们预测图片对应的数字相当有用了。) W9 t% R9 ~/ I7 M* C! w; H; ^( E4 a
事实上这输出中的每一个概率值就分别代表输入图片属于10个数字(0~9)中的一个的概率!' F( Z7 e+ @3 i. Z
- r0 O1 `8 T7 r% D1 a5 W) E* ?编译
* [ ^/ e; f5 X% u! I5 U8 R( Q) X# ~1 r& f
接下来,我们要 编译 这个网络,这个步骤需要给3个参数:2 K% X! l: H+ T
+ [! ]: [5 u; O
损失函数:评价你这网络表现的好不好的函数
" Y/ V0 j6 e( a8 M: i9 j& s$ r优化器:怎么更新(优化)你这个网络
* h7 Q" D! ?% R" J! R训练和测试过程中需要监控的指标,比如这个例子里,我们只关心一个指标 —— 预测的精度6 O/ ]; ~% q$ @) L ?8 s) J0 }
network.compile(loss="categorical_crossentropy",# O2 k6 Z4 z# F) I1 p: S5 U. g
optimizer='rmsprop',
, P1 j. r9 M! x2 | metrics=['accuracy'])
% A |3 `4 o0 K$ K" f+ R5 |1! ?$ `) [1 S- B! v8 _2 g1 K0 x# U. K
2
! Y. c# l/ m% |/ `+ i3, f1 R0 `6 ]4 K: u
预处理
/ K# o/ P/ X0 p& e+ M
. t! n/ I4 b+ g* V- L/ y* g% P图形处理
3 B; m% q; f+ t7 q" ?, R5 {$ M7 R V# |% O3 t" k! ^
我们还需要处理一下图形数据,把它变成我们的网络认识的样子。# Y* y5 i( W7 @/ @% n! G9 L
" h/ I$ b+ R Z1 j& P
MNIST 数据集里的图片是 28x28 的,每个值是属于 [0, 255] 的 uint8。
8 I* u5 }1 m5 {+ o8 t( @# e而我们的神经网络想要的是 28x28 的在 [0, 1] 中的 float32。
4 w8 @+ A; r# l) T6 d7 g6 a/ v' @6 K& E* z1 E
train_images = train_images.reshape((60000, 28 * 28))/ ?( l2 g T1 D9 |9 L1 g2 [# U0 w
train_images = train_images.astype('float32') / 255
7 D1 }0 |" v/ X& B/ J; O. ~4 {& {( Z6 L
test_images = test_images.reshape((10000, 28 * 28))
% F5 r% ^& L5 }; @: dtest_images = test_images.astype('float32') / 255& q- Y" c- b( N+ k, U6 k7 H, @3 _
15 _: |1 d( e# U5 |
2
: \) `( ~2 n0 A7 R* A! D5 ~- a3
/ F( k, _( v! P, `3 d5 n4. M1 j3 y7 D, _2 `+ y
5- N7 P f6 U& L7 D5 h
标签处理
6 N/ s; j1 r* y/ J, I8 n7 s5 E$ ]3 g" C0 [
同样,标签也是需要处理一下的。) \: ]. C4 Y3 u3 R' d
" Z. f' V2 ]* k# \
from tensorflow.keras.utils import to_categorical
. _2 k2 f% ?+ O- v- n; m9 C% i+ q' ^$ }) s5 o
train_labels = to_categorical(train_labels)
: |8 U9 }" ~% B& e! O% htest_labels = to_categorical(test_labels); g+ ~, r+ Q- H' R+ }
1
) V8 j8 Q3 s- H% u! V2' v8 k% K6 D' X+ @, B- J6 v
31 Q6 p7 @% o; _1 o
44 P; @" Z& z" c) G
训练网络! \" \* @2 [! T. l/ l1 k
& B% w. Z3 h8 l
network.fit(train_images, train_labels, epochs=5, batch_size=128)
6 c5 S D/ ^8 w9 e0 d1 E1) ?; r& W$ N8 y- L5 m3 w
输出:/ i) }, D" `% ]) A; x) A
5 E8 @0 s0 |" Y: VTrain on 60000 samples
, B4 \+ C' ^; b2 j$ i1 UEpoch 1/5& a! m+ o; H% Y
60000/60000 [==============================] - 3s 49us/sample - loss: 0.2549 - accuracy: 0.9254$ w2 O0 z1 e% ^% T5 O; o: d6 `) j
Epoch 2/5
! V. b- j4 ^# b3 v {60000/60000 [==============================] - 2s 38us/sample - loss: 0.1025 - accuracy: 0.96939 G' K6 ~- Q+ H2 O
Epoch 3/5& r* l" n2 c# ~. l/ s, N# [
60000/60000 [==============================] - 2s 35us/sample - loss: 0.0676 - accuracy: 0.9800% D& s5 r+ y9 |3 v
Epoch 4/5* P- ~4 V7 C, S+ E% {5 v" D
60000/60000 [==============================] - 2s 37us/sample - loss: 0.0491 - accuracy: 0.98484 T$ |# i0 k7 i% V
Epoch 5/5
- p2 v* y# \8 o8 _" B- r( K' {" z60000/60000 [==============================] - 2s 42us/sample - loss: 0.0369 - accuracy: 0.9888* |! \3 l- K$ e% @
1 {+ s& W0 y8 `
<tensorflow.python.keras.callbacks.History at 0x13a7892d0>6 }# }* b( O. a; |8 b# |
1
8 [4 I% B; x, X* d0 ?) o! D2/ E( h C# C1 z
31 w5 Z: T, y# t! ~
4
/ c% a/ [: q- [' i- N# m3 D5
0 I- t9 N' j7 ~8 C0 L; j( A67 d. n8 b/ d n3 ]
73 J8 @6 ^) U4 z
8' P; r$ Y6 B7 G8 H
90 }9 I+ Q, p" f+ w; T
106 Z8 W$ h) C, b# E' M! T9 L
11
- u! ]% |) y/ F. v12 i: @; o1 D: }% u- o2 R9 c. Y
13
" @2 @. f& H8 U3 O0 B2 T3 E* ~可以看到,训练很快,一会儿就对训练集有 98%+ 的精度了。
. Z7 ^! D# t: K& ]; B* H0 j+ |7 P/ U& Z# K2 S
再用测试集去试试:' f* J$ J0 h$ S8 F: |( L
1 |4 n" S6 U6 J+ N4 J+ H( O( `8 @5 B$ b
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/32286
( m" @& h' Q, P! H& pprint('test_acc:', test_acc)
. K, e6 G( M1 ~' {* W1" y& C4 Y7 k0 u* j7 d8 \! C& m, l2 O* j3 S! A
2* r" ?' U7 {) i- A, n9 P: S
输出:* X4 U9 e, k# h8 j
4 ]# B, c; X" d. E. Z! |4 F
10000/1 - 0s - loss: 0.0362 - accuracy: 0.9789; y8 I( H* m3 B( ~
test_acc: 0.9789
3 T% s# f1 p- u! i1- X6 ~, W# }! W( K; C' a8 Z
2
! I$ ~6 A8 i) u& K i我们训练好的网络在测试集下的表现并没有之前在训练集中那么好,这是「过拟合」的锅。
% J( T8 {% W& p ~: B- K
: D+ g; Z8 @2 Q/ {$ v神经网络的数据表示4 ]+ _& W' q7 ~3 b8 \, W; o0 `) X6 D9 J
& ?) P* ~/ S0 E9 gTensor,张量,任意维的数组(我的意思是编程的那种数组)。矩阵是二维的张量。6 f# R5 A% A' P, y
# y: A8 G1 ]+ C5 q我们常把「张量的维度」说成「轴」。
$ ^, k, V" y* F, W, Z- h3 w! M2 U0 M' E1 U9 D5 z. L8 l
认识张量
. l# k) ~. w: l1 [0 u
& q8 h/ k9 ~* P+ k, G+ ^# t! j4 I标量 (0D Tensors)6 S' J o7 p4 w; p& V
3 l, i8 E0 \2 l& I+ P% F
Scalars,标量是 0 维的张量(0个轴),包含一个数。! I9 T p4 T+ D) L/ v! C
8 q8 }( t# I. \1 K7 O
标量在 numpy 中可以用 float32 或 float64 表示。8 j* L' z! Q# Z5 E) g; ~
% `* Y5 h4 X2 \1 V; `" n& r
import numpy as np
- i6 D- z! O* y" b- w# t
" z2 w2 ?% L2 \9 @% g: Cx = np.array(12): D* U {" ~8 T$ |
x
) j( F+ A6 j7 J; }3 F# C* }19 B6 b9 y5 Y3 j( ?. U
2( A- M! A: Y+ v4 a
30 X8 y; ]5 {- {$ }
4
: D! N5 s! n0 |' o8 ]) f输出:3 z8 F3 ^7 C+ Z9 g" D" f
" O* n! q+ T2 O8 farray(12)
2 e6 Y9 P$ ?( e' \ u1
+ }" k% i* } r, v! b, z. wx.ndim # 轴数(维数)' J: y+ N$ u7 d4 y/ S( o
1
$ x2 \+ `6 [0 `输出:
" V% Z+ G! Z8 l9 A4 T) w/ M f0 s! H9 ]0 f% ?
1! a5 F1 a2 |) B2 G9 y. q; F$ ]
1
: \1 M4 |# b, U. N6 K! q向量 (1D Tensors)7 T& p, }6 d! L9 g9 ]. J% X; z4 o
2 b, x: ?( E* I0 d1 j& C/ A9 f
Vectors,向量是 1 维张量(有1个轴),包含一列标量(就是搞个array装标量)。3 z8 V8 K( a/ O: U9 }9 W. v9 ]0 U/ w
" J8 G. E/ z% k# f1 Y7 V
x = np.array([1, 2, 3, 4, 5])
, B! n$ v% n) d6 [- N; _x
* S# d# w( E% h& D% f/ V2 M1+ o) _ O2 ?: [4 s% ]" d
2" v7 W6 `- m3 V, ?0 b
输出:$ O. ~( T% N! w) d
, G$ a7 Z' D# v) s
array([1, 2, 3, 4, 5])
7 D# `! S7 r+ o* O1
( ~# i7 g3 h6 i( K4 @7 @" q" w2 cx.ndim
8 ?2 c z+ v: _& l2 D4 ~% z1# Y* S0 l4 V9 V* p. l/ ^) Q7 e
输出:$ O0 J6 G5 W9 y' w; f' P) n- I" i9 t
) K9 @( E) j4 F9 z, s* ~1' V: R6 n2 M' o$ n. b, i! T* l
1! ?) |' V$ w z- g+ @
我们把这样有5个元素的向量叫做“5维向量”。0 W' _( Z" K+ p2 H* w8 {
但注意5D向量可不是5D张量!
0 }6 U+ S4 ?! e) ^; q
+ y0 m$ I, Q. m5D向量:只有1个轴,在这个轴上有5个维度。1 H$ W: Q; Y( r9 L) |! M f
5D张量:有5个轴,在每个轴上可以有任意维度。/ x& S3 d) O. g& @
这个就很迷,这“维度”有的时候是指轴数,有的时候是指轴上的元素个数。
! Y( y6 }/ x) O! q$ B) w9 b/ E3 a) K0 e( p* V ]) \# z4 X
所以,我们最好换种说法,用「阶」来表示轴数,说 5阶张量。
3 i6 Z) p, L1 s8 p! O9 z, Q% b9 D% L. i+ Q% l$ \
矩阵 (2D Tensors)
+ B! K0 q2 @1 ^ e* j) `, a4 v% | h/ ]+ b, d1 o9 d
Matrices,矩阵是 2 阶张量(2个轴,就是我们说的「行」和「列」),包含一列向量(就是搞个array装向量)。
+ n; e4 p( F0 {, h: ?1 `: H
5 M: Q2 ]# ?% O4 i1 Y- Nx = np.array([[5, 78, 2, 34, 0],
" d; U8 @# w. D0 I9 ? H [6, 79, 3, 35, 1],$ f; T! l) P1 }, D/ g6 k6 ^
[7, 80, 4, 36, 2]]): }0 J$ D$ E/ M" k- }$ }2 v. V% X7 ?
x
" b9 u5 S( g d1! R4 B* y& h5 K9 j/ C' q7 F
2+ F- S! G' z( W; ^5 Y, E, S
3
+ a! W) T. {) h0 e0 {. g, z1 c4
/ U( P4 H# s; k+ E% b( y, k* q K输出:6 c& I5 E0 @- K$ r9 A8 \" n
9 \2 {( \! W+ E) a0 `
array([[ 5, 78, 2, 34, 0],9 c5 z7 A# ?9 G+ c) N8 ] }3 s/ b
[ 6, 79, 3, 35, 1],
5 |; o+ `) k; M7 S [ 7, 80, 4, 36, 2]])3 t/ R2 s6 b! T1 p9 f$ O) M0 U
12 Y+ l* `% X: u# P
2
4 K' u4 {8 O& m7 A3 b9 {& f. Q3
& a* K# P, t3 z9 T! J3 @+ Tx.ndim& Y. `6 Q( W3 U9 ~7 r2 {4 Q! O
1
" Y1 a) m. p f1 j4 L3 A9 m: k- a输出:
% |9 h+ R3 R" n9 r7 z6 y# P' n' n+ `4 S& u# ~
2
. r$ n) \/ V; E' p$ ]1& E, o1 `, g( V7 i) o5 j' |6 C
高阶张量
) Y2 U* }' I& Q) S
/ [0 o4 A/ D; X+ F$ o0 \你搞个装矩阵的 array 就得到了3阶张量。, T$ q/ h' e8 d! r! k
7 s: U6 K9 R9 J2 b! C/ i2 H再搞个装3阶张量的 array 就得到了4阶张量,依次类推,就有高阶张量了。
x' |% N9 B# [" a
3 F" H) ]! m6 T5 }' j/ h! G: k& kx = np.array([[[5, 78, 2, 34, 0],
* d6 K1 j9 M4 ] I+ [ [6, 79, 3, 35, 1],
( v+ ?+ E8 T: z% z: k$ I8 t [7, 80, 4, 36, 2]],( a, p" H# c# v& O
[[5, 78, 2, 34, 0],8 w$ t$ Q# A' S. K {0 o
[6, 79, 3, 35, 1],
1 n1 r6 ~* L: v- _7 \1 z [7, 80, 4, 36, 2]],
; I* H( o5 r" l3 u% Y4 i/ c1 F- X( ^ [[5, 78, 2, 34, 0],1 v9 ?5 `! \! r, W
[6, 79, 3, 35, 1],
5 L8 [: w) u# A! Z' ~( N* a7 M; O- `3 c [7, 80, 4, 36, 2]]])9 ]% S2 |% d; `6 }7 r+ b
x.ndim
6 h. o; q6 m' t+ [3 X% i1
* b- G1 A3 B' G t/ ?# _7 q24 u: Z+ T( q s
3
/ I4 @% Z/ Z7 K, e3 `- g4
* Z3 A2 W5 g1 q* n& E3 P3 h& w7 C5# B7 P6 y: r6 A
6
* C$ L. } w0 Y# k1 ], a: o7
5 z b/ n' W1 e5 C+ L; t& r& t, v8$ C7 U/ ^6 H' K5 J
9& k. N$ e; _/ O
10
z+ n; a, V3 f输出:$ b3 y5 x# a% B3 d/ d( q
( Y" \- ]; t5 l. ]& j* D C a
3
$ @( i, O1 e, `6 ~$ Y m1
" l5 k d; R5 j! j- v深度学习里,我们一般就用0~4阶的张量。" J! v1 |" W: e1 U
' a) @& \ N$ O' c, P; E; e4 v
张量的三要素
! i: s$ I: ]) o8 K, I. K- P' ?; }/ b, L" |; g3 T
阶数(轴的个数):3,5,…1 b) w* G+ u% V0 S
形状(各轴维数):(2, 1, 3),(6, 5, 5, 3, 6),…
. C! ?2 K: m1 Y: }4 s; \数据类型:float32,uint8,…
& C9 F% K4 v! A' J我们来看看 MNIST 里的张量数据:- v# `6 X& ]$ x& i( y) S
2 C3 \5 Y {* C6 X9 Ufrom tensorflow.keras.datasets import mnist
U0 H$ S- }% h0 d(train_images, train_labels), (test_images, test_labels) = mnist.load_data()% C, L7 X9 Z) f
: O2 ?$ x; T' |: Z" Lprint(train_images.ndim)9 I1 h ^2 l" i" h0 ]9 ~- z- G/ l. W; M
print(train_images.shape)
; {8 `* [4 u. g2 L) Rprint(train_images.dtype)# Z V' {, `% l, C) w3 i, V2 v& g
14 {. b5 S+ r/ G" ] s
2 |, V3 p0 P! @7 s2 ^$ E
3% i) F4 S0 e, a2 ~$ P) V" R
4, e1 g6 P1 d" \6 i' Z u
5; w# B; ~7 b& Q, K
6" s% P y! c8 G1 I( |4 s$ \2 [# V/ `0 }
输出:
9 q; @* \6 m1 `2 N6 Y% k& E4 f z& ^$ h5 f& R" S# e. E
3. G) `7 [' G' n+ f0 V* V
(60000, 28, 28)
V% W9 [( _* N7 [/ p3 p) M5 Wuint8& x, f" j% S2 J9 h
1
* U' z# ]: }2 D0 t# F( k. s: T3 y2- l$ U8 y, Q: T# s0 c) N
33 ~5 n/ ^1 G: @. z9 p
所以 train_images 是个8位无符号整数的3阶张量。9 i; \ m0 V- @$ O- n! P
: l& e+ v; `: D: f% a打印个里面的图片看看:
! y; D8 |+ j$ a. [0 p3 k+ m2 n( I
digit = train_images[0]) q. w% _2 q" S
2 T+ b+ b" v8 B# j* w9 Z4 ^* [: O: dimport matplotlib.pyplot as plt
) F, T/ [! H6 o1 O" |; r1 u1 i- ^
3 g* I7 ?5 P2 h+ s2 f" A5 Dprint("image:")" K7 `- Y. U# h/ u; G
plt.imshow(digit, cmap=plt.cm.binary)
* Y9 I# N( H' S gplt.show()- L1 W Z# i2 Y2 y7 X6 S
print("label: ", train_labels[0])
( m* \6 p0 S$ |/ R5 y1! x! _1 n/ q4 A9 M) `3 F- ?1 t
2
( ^! m4 z0 N( N2 g3# }' L4 O* E% U
4
% @2 s/ ?& Q0 G' e5
+ m0 Z5 Z: V% Y% ^, A68 N0 A4 F) [7 g: @! t* F
7
0 @1 }. {8 y' V: b8 m: m8- d9 \$ p4 A& B) C& G/ b' h
输出:$ j, s" `2 ?# n Q. w; D+ B
) r8 n8 M& M8 L* d8 F! A( N
! r0 G9 O8 v8 B- F- m
3 g. t0 J$ q8 M9 g( }
label: 5
4 O$ ~' L& l) p$ r) O% }2 Z1
$ B& z' z& L; j0 _6 m' k: \Numpy张量操作; d/ y9 ~ G' N; P. Z: p
" T4 x n r7 C张量切片:8 `/ q- ~ `# x3 f- k+ W6 b2 z
& e3 p6 H. s- x, Omy_slice = train_images[10:100]+ Z! b ~+ u& B0 R8 L$ x
print(my_slice.shape)6 R: H! g" W# o1 a# c
13 t9 |- s0 |/ c1 y. I% Z
2& h& V/ {% L& h6 p7 M
输出:
* ?* _6 ~8 v+ M
# |9 `: b \ ?
(90, 28, 28)
" M: W" v, T% T1 b$ J+ z1
* }% N& U3 E. H0 j$ d; O( b等价于:3 K) E* T% C9 @ p: G5 m2 n3 J
$ T A& d* k: v: }1 x, I# o
my_slice = train_images[10:100, :, :]
0 z! F2 O8 c0 l: P7 J: Vprint(my_slice.shape)
m; ` ^' s' O4 {+ k+ S# C( {1, ~" `# J. v6 v j3 O
2
6 Z3 ?7 l7 v7 Q$ J& E( \. x输出:6 e6 |4 G* t! V" {
9 h5 r) V% D2 [(90, 28, 28)" i7 Z( v0 F) V5 }
11 `- e& X. ]$ O' u2 K
也等价于
% k# u( F, r4 D7 K% k7 s8 }
1 F: o0 b1 c! c9 ~1 z2 A/ _3 g; Vmy_slice = train_images[10:100, 0:28, 0:28]$ z: k& y& N& f* ^3 k* C
print(my_slice.shape)
" g R* V) t' U1
7 g/ f5 t1 X& }8 c( o @2& ^* i$ N: \% G0 P
输出:
, I8 b, R+ T* Q$ j, {7 h
M7 m4 W, f5 s0 R: M(90, 28, 28)' t ]" J- c; A
1
$ ^" m, m ^' z1 Y* ?选出 右下角 14x14 的:' b6 @5 {( j# |
' N6 Z* Z# N" T; O% k( }; q* V. J9 g1 Q
my_slice = train_images[:, 14:, 14:]
. I2 k' [9 N; v. p0 H+ iplt.imshow(my_slice[0], cmap=plt.cm.binary)
$ w6 b# I) u' S" {1 W6 Kplt.show()) z* F" p2 ?+ j! H
1
9 \& V ^- E0 B. }2/ ?4 H1 G9 `$ x8 v$ j0 j4 i p+ ]
32 W1 c2 w% r9 i+ g& I1 c
输出:1 D: E4 ~; P/ @ q
0 _* [5 G' D: z6 ^0 ]
9 _. Y. R0 B2 \9 `- A. k1 t
! k- A2 Y- k; n选出 中心处 14x14 的:# U+ T# C7 a# J6 ?* ^% y
t/ H' d' s8 U! r6 [6 h
my_slice = train_images[:, 7:-7, 7:-7]
! V. s5 G% s9 Q, u. Bplt.imshow(my_slice[0], cmap=plt.cm.binary)
6 l3 O& t( w5 Fplt.show()
; B) T# D4 u9 O. B11 i: i) R+ A3 h, E( I0 t; p) ~
2
, m1 _. u, u+ d' {8 S4 Z0 t36 N# N/ [; p) m" v2 A. p% Y
输出:2 e+ @8 _- {1 m: ]4 w0 }: x' _
% M6 B3 d6 T: j# h: q" q
- A9 ]- I0 N; s" W3 {; t
. ]6 K4 _& M, j( v, B& ?9 {数据批量& r6 `" n8 L& Y* K5 d
0 z: w1 z# t0 J4 I0 J- i深度学习的数据里,一般第一个轴(index=0)叫做「样本轴」(或者说「样本维度」)。4 t$ E0 M7 X5 F0 _3 F8 l
: q, C. O6 }$ H0 E, _7 E9 E: h
深度学习里,我们一般不会一次性处理整个数据集,我们一批一批地处理。2 L' n( {1 t) g2 [
+ z9 q! n; {' W1 ^在 MNIST 中,我们的一个批量是 128 个数据:
" Y( |& ]+ g( l; c* l F+ f
6 o- x* G1 V7 Z# 第一批4 q0 `0 A) W" Y3 k/ _$ m
batch = train_images[:128]1 k1 z- l" L; \
# 第二批, J. b, O5 Z, q3 b- e @% y8 Q
batch = train_images[128:256]9 ~2 k) z( d) F3 n* B! C
# 第n批
( M2 J% Y# B8 a' }( L, d! |n = 12) v' D4 \! k! S! z$ {8 P" a: j
batch = train_images[128 * n : 128 * (n+1)]2 W7 a7 y! j1 l
16 H$ x. J3 ]. _# L
2& x% X; Z6 q4 }* j! t
3
" {0 c/ h7 U# f8 [/ ?- n) O4/ v! T. ^( p2 e6 j9 C8 k
5
5 |+ p" I6 C0 k; R' i. Z. D66 ~6 l: V, @. r( m
7
2 z4 K$ K, H$ w. o( H所以,在使用 batch 的时候,我们也把第一个轴叫做「批量轴」。
: S: h1 J( Z& q$ G7 f% M3 p% S5 a4 ^! Q2 ^. |0 t7 n8 e* E6 H$ ^
常见数据张量表示
( y6 H, W; K! \. l
! Y: p9 r) ~' T. G. Y1 W数据
& v+ A4 S+ l+ h |
zan
|