- 在线时间
- 1630 小时
- 最后登录
- 2024-1-29
- 注册时间
- 2017-5-16
- 听众数
- 81
- 收听数
- 1
- 能力
- 120 分
- 体力
- 539940 点
- 威望
- 12 点
- 阅读权限
- 255
- 积分
- 167360
- 相册
- 1
- 日志
- 0
- 记录
- 0
- 帖子
- 5324
- 主题
- 5250
- 精华
- 18
- 分享
- 0
- 好友
- 163
TA的每日心情 | 开心 2021-8-11 17:59 |
---|
签到天数: 17 天 [LV.4]偶尔看看III 网络挑战赛参赛者 网络挑战赛参赛者 - 自我介绍
- 本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。
群组: 2018美赛大象算法课程 群组: 2018美赛护航培训课程 群组: 2019年 数学中国站长建 群组: 2019年数据分析师课程 群组: 2018年大象老师国赛优 |
# k; c* d" B) a0 {6 _& u# `Python深度学习之初窥神经网络# h. @' J1 r" n6 `
本文为 第2章 开始之前:神经网络背后的数学 (Chapter 2. Before we begin: the mathematical building blocks of neural networks) 的笔记整合。# _$ m- _; F. v C# F3 y/ ~
6 i# t4 H5 l# X" L5 `$ J
本文目录:' X0 o4 O2 j! ~/ I4 A
4 Z# @) K2 g% o5 Q. K
文章目录
, N+ I+ q. y; X4 K/ [9 {- A1 j; E# v( D- {& o4 E
Deep Learning with Python
8 m3 G5 Z9 C& o, n/ y- Q& P) M初窥神经网络
7 j( l7 @8 s: Q, V- a0 a; Z& A导入MNIST数据集
. o( A* S+ @% W# T) M1 }网络构建5 v- ~7 j5 s- t
编译5 S0 }7 k& g+ z. z1 `
预处理- R m6 q3 W9 { O1 F7 y
图形处理
+ |4 g3 }0 R0 n标签处理
7 X" W; ?' ~7 D' U! x) }, a. _训练网络
9 k3 {: b# T- t. C1 ]神经网络的数据表示
* ?( ~$ n- y; R认识张量
9 m- M3 P6 W6 K4 h( V+ W标量 (0D Tensors)1 T* H8 W" W! E. a4 C
向量 (1D Tensors)
6 t6 |) O/ m d3 ^矩阵 (2D Tensors)
0 ~: u+ _& B" }; W* M5 a& [9 H; o: m高阶张量
. _: e$ ^! S1 t3 ^张量的三要素
0 x( G' t: `9 U$ B* Z. V$ W, h' g6 oNumpy张量操作8 N$ Q5 Z, Y* y" Y h, y
张量切片:
1 W9 F2 M( m( R$ f4 Q数据批量 D) }8 U5 P6 y# J" N/ R2 [
常见数据张量表示/ C; k. M) p5 L* T' `9 ~( l3 f
神经网络的“齿轮”: 张量运算
6 l0 }1 `1 J( `4 j; z+ k% P逐元素操作(Element-wise); V4 u- C7 c+ b) W# h
广播(Broadcasting), _$ y2 `2 x+ s1 X
张量点积(dot)
9 O; T& h) `& @& j) T* x张量变形(reshaping)+ ^$ K) e+ S+ g; R4 P
神经网络的“引擎”: 基于梯度的优化
% B" s& C3 }* R. X8 ^; J导数(derivative)5 |1 I' y4 O0 @
梯度(gradient)- ]' n4 E4 s. S r% |! I! i1 y8 D
随机梯度下降(Stochastic gradient descent)7 t. N5 U/ c, J+ K6 }' Z: h0 o9 }
反向传播算法:链式求导/ w9 ~' Q. L5 J# I
本文由 CDFMLR 原创,收录于个人主页 https://clownote.github.io。4 _2 i* `# y% L3 v
( R( {$ N3 G f初窥神经网络
( J0 K6 A: y0 H6 r; q/ f2 _! {3 J- D3 o! t" `
学编程语言从 “Hello World” 开始,学 Deep learning 从 MINST 开始。# f: M7 _. V9 U; a9 }# O! F
7 k5 W! V; y! D [6 {5 [5 R2 A1 l
MNIST 用来训练手写数字识别, 它包含 28x28 的灰度手写图片,以及每张图片对应的标签(0~9的值)。# X' X3 Q+ y. Y" X
* @* Y$ P) j- R. t* n) n$ S2 N$ |导入MNIST数据集" ~1 K% q' y4 a5 W# E6 x8 Z
9 E- i1 r5 @( Q, `5 R* |& U
# Loading the MNIST dataset in Keras
! o9 c& l) L$ b u8 K# Q! Hfrom tensorflow.keras.datasets import mnist
: x" A" A5 q) h5 S4 y! a/ N(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
" t$ {3 D( l& R+ h1, p$ |6 L) A& k1 ~# G9 B- x
2
& _* k" [- x; w5 k4 g/ c, h2 S3. c9 K, _7 Q9 A1 z a; w
看一下训练集:# \, p- [4 Z5 ^* L0 `* r, _
0 o3 A$ B0 i. yprint(train_images.shape)
|* }* s0 ~. t2 I: x- Zprint(train_labels.shape)7 V9 _: ?7 P4 z _0 s: V0 H
train_labels
b; r5 Z8 ^* m# X+ U1
* w J4 ^; s( \' Z1 V+ g% q* b2 ]24 ]% V8 g+ c! n) p' \$ L
3: M q3 H* r d: A6 f8 m
输出:3 P( x9 U% V; E( A7 S ]
- z: ?7 m9 R( n2 i
(60000, 28, 28)9 m6 O/ e& k+ N1 y- x' b' r
(60000,)1 r5 D& M5 p, I+ V! C1 [
/ Q3 p' b$ H5 T& n" O" i
array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)7 D# U4 S: c. p1 r7 ]$ R5 H, |3 ?8 K3 S
1
0 R' B5 X$ Q/ B2
3 x' A5 t" O9 M y7 O3/ k% J5 i$ m! L! D; W/ d
4
! K5 m6 y; S- i: |) S$ ?$ p这是测试集:
, Z. ~% i5 z3 e6 D+ W3 c
% a( E5 v" F J6 X! v0 X& p1 Oprint(test_images.shape)
$ R6 R* k+ L T6 P/ Qprint(test_labels.shape)3 C4 {* @0 _' E/ J, f. | I# l
test_labels+ a, S0 q, \% t# q# e$ W0 ?( x
1
b1 E/ f5 l& z2
/ ~2 y% S) B" n3
, D$ e$ x2 y0 A% ~4 W- f1 {) g1 M5 u输出: w/ z4 ~* I9 c, J! G
7 @+ Q- N9 Z9 h' E
(10000, 28, 28)
, L% \( V# c: e, R% s# P(10000,)
4 G3 m7 v$ d R5 B# `9 J( A/ m
+ z$ X; l+ E! w8 Barray([7, 2, 1, ..., 4, 5, 6], dtype=uint8)
5 ?$ `6 o8 U% w1 z* ~1
( C* ~5 Y! a; t% Y S7 R2 `9 D) Y: ~& K1 n, o8 E+ ~; o9 t
39 H I5 _7 ^% Z/ `# Y' N5 |, ^
4
3 e2 B7 I2 ~( s; W2 ?5 j2 U网络构建5 X6 O# N8 b1 ?8 K5 i8 S
) E8 C8 [, h4 N8 } Q7 `, J, L+ U, X我们来构建一个用来学习 MNIST 集的神经网络:* ^0 N0 W n" n3 a+ R
' b% P5 A1 W- P, J: r
from tensorflow.keras import models5 c ~% J" V* K( G) y: k
from tensorflow.keras import layers
2 f: F5 U. _/ A* p( n
/ B4 J V j4 ^( znetwork = models.Sequential()' v! u# v; N$ Y
network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))" b# ~5 T6 E% A$ x
network.add(layers.Dense(10, activation='softmax'))
% c! O- k& a Q X' ~- N5 n19 I& S) X) D1 `2 h% ?. B' {
25 R+ L" [4 B q2 ~$ Q
3' j8 J( G3 v( k! ]+ v4 {( I
4
; R8 v& x% s4 U9 i3 F" b! C8 n Y* S5
8 o5 x& y1 g6 U+ ^" E2 Y1 x6
0 g7 _/ [: u# [0 e( N4 K ]神经网络是一个个「层」组成的。& v' ?! G" B) S+ }1 `' ^+ E5 x5 r
一个「层」就像是一个“蒸馏过滤器”,它会“过滤”处理输入的数据,从里面“精炼”出需要的信息,然后传到下一层。
" `+ e3 u: a( K
3 y% |0 O9 E, X( q" V# \2 b( L这样一系列的「层」组合起来,像流水线一样对数据进行处理。4 v2 F( ?* B9 E6 J# W
层层扬弃,让被处理的数据,或者说“数据的表示”对我们最终希望的结果越来越“有用”。
* x& u7 I( e* ~
( G6 G* S. u& F# ~5 x. v/ [4 s我们刚才这段代码构建的网络包含两个「Dense 层」,这么叫是因为它们是密集连接(densely connected)或者说是 全连接 的。/ j5 }; Z# u- @$ w& e9 s( c
/ S6 v( m/ y7 Z0 _4 h4 `
数据到了最后一层(第二层),是一个 10路 的 softmax 层。2 J- d1 T: N" m
这个层输出的是一个数组,包含 10 个概率值(它们的和为1),这个输出「表示」的信息就对我们预测图片对应的数字相当有用了。
7 R, z) Q9 r. }( y! D事实上这输出中的每一个概率值就分别代表输入图片属于10个数字(0~9)中的一个的概率!
5 @( E% V- p9 l+ I! I4 O; a/ ?
5 j" I5 w0 L6 `' ?编译
" L; T) w1 u: I5 x: N" q6 @7 a# ^1 ]
接下来,我们要 编译 这个网络,这个步骤需要给3个参数:9 p7 I+ t. \$ Q' B3 B
* P+ U; ^3 G8 K: u4 U损失函数:评价你这网络表现的好不好的函数
& I9 \ w: k. i; H G2 w优化器:怎么更新(优化)你这个网络
( g8 s- P* z7 n) h8 d训练和测试过程中需要监控的指标,比如这个例子里,我们只关心一个指标 —— 预测的精度0 {$ P9 ` V d V, a' `
network.compile(loss="categorical_crossentropy"," V. E# @) D, s5 E4 u' A& J
optimizer='rmsprop',1 U. g6 E1 w" e0 G0 g% q
metrics=['accuracy'])
8 K y% \, S2 J, J7 U3 g1- W1 X1 ? U# e# I+ N6 q
22 C. w! }4 I* V+ {2 ?7 z* V
33 B' d/ d" c/ f
预处理
V' i* L5 }4 Q( v/ W1 m% T4 }' c2 D0 `
图形处理
5 s; }3 K' \7 j1 T7 p8 X/ N1 e- b
我们还需要处理一下图形数据,把它变成我们的网络认识的样子。& y3 @9 C4 S- |
5 U0 T% g7 y$ W7 r ]
MNIST 数据集里的图片是 28x28 的,每个值是属于 [0, 255] 的 uint8。, n- q% L( _4 z! j# L% |2 y/ `
而我们的神经网络想要的是 28x28 的在 [0, 1] 中的 float32。
& Q5 F9 |' w ?5 M- T. ^ y9 V
; n, y% C! e5 |train_images = train_images.reshape((60000, 28 * 28))
$ l: H9 U6 @" V+ z% O( mtrain_images = train_images.astype('float32') / 255: r6 ^6 B9 M8 b! P- N3 f7 r8 @
7 R4 g" P2 `1 n5 ?3 x+ V3 Stest_images = test_images.reshape((10000, 28 * 28))
. _( a3 _! G: Y0 ~4 ?" Ttest_images = test_images.astype('float32') / 255
3 U6 F1 y( V, e) v5 {( M$ j1
1 h$ e1 [5 P$ s2
; M* M5 W) X; e' g [3* B2 K9 l' x+ V q5 ~" w
4! k1 I% e& l3 G: ~) @! d5 t
5
4 f7 w$ u- Y; Q6 d1 q/ W6 W0 X标签处理- C# d9 T9 y. _
& N$ U4 L7 q" v0 R" _& N同样,标签也是需要处理一下的。
' g; I5 c& ], L: M- z4 _$ ?
- h8 z2 F5 n; @2 o2 V3 G6 d( A, Ffrom tensorflow.keras.utils import to_categorical" v# Q) H% o7 S; ]2 z J
, S5 P1 _* f4 f' u2 C% J3 ntrain_labels = to_categorical(train_labels)
, M! N; ?; P. ?3 l ]4 @+ V! Z& b, Etest_labels = to_categorical(test_labels)
6 n: k4 J7 A1 ?1
% l; |! @& y$ ~: Z1 y0 l4 B2
5 c) I3 A" H, {3. S4 }- a, m& Q) x: r! [
4$ u$ f, L J1 J; M% F, |3 U
训练网络/ [: K/ l! T3 {9 O
8 v* M+ r* {0 e cnetwork.fit(train_images, train_labels, epochs=5, batch_size=128)* {7 Q; l% h6 j% \) ?* }$ ?7 ~4 A2 L0 r
1; ~' [4 X5 }/ G' D$ [
输出:! O0 x8 M$ e. V7 Y0 E5 ] r
- ?- G, v: Y/ r3 s1 R/ uTrain on 60000 samples
, ^ d3 G7 r C) ^Epoch 1/5
/ J, r# v; }% Y60000/60000 [==============================] - 3s 49us/sample - loss: 0.2549 - accuracy: 0.9254# C6 `; q7 u2 W8 U
Epoch 2/5
8 S# E$ O+ I8 j0 {60000/60000 [==============================] - 2s 38us/sample - loss: 0.1025 - accuracy: 0.9693
0 B; o) d: e( Z' G, ]# GEpoch 3/5
7 R& S4 W) ^$ i/ s7 k60000/60000 [==============================] - 2s 35us/sample - loss: 0.0676 - accuracy: 0.9800* y* `: Y7 L" j. F: ]+ ]
Epoch 4/5/ D/ I! V3 r. ]7 _. R! X* g
60000/60000 [==============================] - 2s 37us/sample - loss: 0.0491 - accuracy: 0.9848
% h& M& k8 t3 x5 I7 t+ JEpoch 5/5
& ^3 g, R$ e: ]6 K* a* M5 R60000/60000 [==============================] - 2s 42us/sample - loss: 0.0369 - accuracy: 0.98881 E3 T L# L9 S' ?& x
; R" `& y( f+ m0 I) d& c
<tensorflow.python.keras.callbacks.History at 0x13a7892d0>
$ M5 M% N6 Z& ]$ }& K1) Z* J5 }; V- k$ t6 ]* C! l
2
3 T/ k9 r2 K( X( b32 f9 d0 O8 n' b7 {) J
4
; Z) C- i$ A, H& P& o0 |# b5
7 X+ D& j+ U/ T8 w+ E6 {' H0 }, G" U# a- f
7 W: d6 V3 s! q$ t0 E
84 g& `8 D* ^4 e- e3 ~* T
9
9 ~' d$ M( [* k4 o ? O10
5 W) d8 Y8 B. B. t$ T! g% h9 ~11
9 s' R M) L! A3 Z12: ^. ^: @2 A) s
13! y" h1 X) }+ Q C8 R
可以看到,训练很快,一会儿就对训练集有 98%+ 的精度了。% Z4 R( ~$ O: \" v/ J
, b7 q% U h: v' O4 |, r7 c
再用测试集去试试:; E& A6 H+ S, a0 P
* p# T& r9 D. r6 {( vtest_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
, E# q! @- m: J7 ^0 fprint('test_acc:', test_acc)" X; M0 p- J, @, N5 d
1" H7 H" {: i7 `' l, D( w
2
2 B4 F% A% _7 I9 o/ _- m' ^+ n输出:0 C6 ]/ H2 C/ u8 a8 S6 M
$ j$ p& R5 N3 J, ~- ?) f, o
10000/1 - 0s - loss: 0.0362 - accuracy: 0.9789
+ U$ {! o0 t9 T% i$ Q, btest_acc: 0.97894 Q+ h6 M6 Z+ m0 E( P
1. c6 I; q. `& j& z0 Z
2# E! P6 S3 \8 Q
我们训练好的网络在测试集下的表现并没有之前在训练集中那么好,这是「过拟合」的锅。( |- [4 G3 X; _3 Z) f ?- Z) J5 F
; p1 H: S/ l+ C- p8 u1 `/ s- A
神经网络的数据表示
0 D/ W! X u8 u( \1 e. o/ X5 T$ c1 ?
Tensor,张量,任意维的数组(我的意思是编程的那种数组)。矩阵是二维的张量。
4 Q& \5 a- \+ l0 j& e, Q& r$ T- I$ X4 U& U
我们常把「张量的维度」说成「轴」。0 U G7 g* `2 K. _4 c) ]) I% J/ A+ z# ?
( y. A! p9 z. k, K' M4 R认识张量2 h7 k8 ]5 e$ n+ V- `4 |; t" j
R$ }6 p7 O* v; d
标量 (0D Tensors)
: }+ y; w7 I; F* a* ] B3 b3 d
0 f" q f# E: kScalars,标量是 0 维的张量(0个轴),包含一个数。5 }0 T2 ~4 o+ h' c+ s' _" b& B
* U! g! L1 S2 {; j$ ^4 S* a. w标量在 numpy 中可以用 float32 或 float64 表示。
7 r) X4 O9 x1 i3 s/ ?2 U. k" f! d% {" \ L; M
import numpy as np! s3 _6 J: B0 a W
& w0 u+ d/ c% d- ]- t& G8 B- wx = np.array(12)% J R" E/ q& g4 u2 K3 F% W7 B, O
x
/ R1 w+ w% s" W: @1
], _& K* a! Z; d1 O7 C' F2
6 F ]) e# h7 Z9 K- L0 Q3
W* x5 g: [4 Q4
w4 U* S: w# E7 P9 g0 D输出:& R) v& d9 J% s" r5 A2 O
. f6 c% k9 s6 ?! t
array(12)
5 `& b2 J, m0 ]% f6 n' \1
) A x; r% A0 `/ gx.ndim # 轴数(维数)
# {2 ^$ g3 I5 A% G B1
' r7 R/ L- x9 T, q9 N2 I: |( Q0 l输出:, F. G: c! h8 G# _* a$ g
% C5 ~- y, Y# c2 Z6 D1 h& U
1
+ I/ k$ @ p# @# B/ n8 s0 L1, r0 m2 p# f. \4 _
向量 (1D Tensors)
* b) ]/ H% Q% f
7 W8 }8 H- t3 ^6 P+ M& F! iVectors,向量是 1 维张量(有1个轴),包含一列标量(就是搞个array装标量)。
. V# [5 L8 D/ ~1 M6 P* E, S& D% e. Z, F! k2 P- l8 C+ {
x = np.array([1, 2, 3, 4, 5])
- i) i" c; s w( a% x7 m1 A, A* `% n9 _x8 B$ W. H7 } c3 f. R8 F: d' H
1
# ~: {3 L6 d3 @- B( Z2
5 l# C; \1 h/ b! `输出:/ v4 `! j0 p2 N- W
: {8 o* J8 z; {) ]7 I4 e* i$ K/ T _
array([1, 2, 3, 4, 5])7 b4 u; R4 j4 c N, X8 }" v
1
9 Z: F' ^# ], ^) p: p/ J0 lx.ndim
8 Z: m6 O2 b* H4 c Z2 j1+ ]& [$ x V* L# r+ o6 \+ t) w
输出:
3 n: B; {. g3 e$ y: H- ?2 u2 v
7 r7 Y* O' L7 p$ h5 I2 \1
]* i* Z( Y! ?+ a1 c+ r& y% c$ k& i. K- \, ~
我们把这样有5个元素的向量叫做“5维向量”。8 d: M8 ~/ s$ Z9 S$ V( a
但注意5D向量可不是5D张量!6 B0 b2 e0 n. L9 A X2 h6 {5 D
' u( x. Y& x0 c5D向量:只有1个轴,在这个轴上有5个维度。
9 [ B6 e/ u8 I( ?3 O6 j5D张量:有5个轴,在每个轴上可以有任意维度。( Y+ e: j6 w- z) B7 Q. y, c& _
这个就很迷,这“维度”有的时候是指轴数,有的时候是指轴上的元素个数。 l6 u6 Q, Q3 M# g: T2 A2 z9 W
$ f$ B; ]' k8 s3 Q& o9 T所以,我们最好换种说法,用「阶」来表示轴数,说 5阶张量。& X9 C* P; F( j- ^7 }
6 }( V: j. h0 k* ~0 x
矩阵 (2D Tensors): i" ^% N' ?+ x7 s* q* r
! b9 G3 P6 e' s5 K0 C1 J. L
Matrices,矩阵是 2 阶张量(2个轴,就是我们说的「行」和「列」),包含一列向量(就是搞个array装向量)。0 ^! O: c; o' l& f, g
+ J! z+ O5 C: D) w& E7 }, d2 C* q
x = np.array([[5, 78, 2, 34, 0],# a( B) S o1 ?. ~
[6, 79, 3, 35, 1],2 G" }: N: ?, }5 v
[7, 80, 4, 36, 2]])' [) c( ?% A* T v
x
?+ x5 v5 g, \% X9 C" [1
, W+ z: s8 P7 w8 e& {; d, x2; g- {7 @# J! P% p, [6 i
3
! ?+ T0 Z# P( Q6 h" }47 i# k: S9 w4 K- j/ A
输出:, ?5 z# i2 J# Q- v% F
: y ^- V4 }( t; s, G2 W
array([[ 5, 78, 2, 34, 0],- V. E3 X2 R& r* k& v- `4 m
[ 6, 79, 3, 35, 1],
0 m z( L% C& _$ M! h- O! \ [ 7, 80, 4, 36, 2]]). f9 y: |* b9 U
1
' i- x5 p8 I& k8 R: K% w2
8 s' `8 D9 V% m" T' t X3 D1 @8 a, m6 u; O+ E0 O, F
x.ndim! J2 Y& N7 V3 }+ _$ Z
1
- ]9 o$ L+ z) S0 K输出:# p) z- Q% O& G7 i, k
6 e8 P) N! t6 k- ?9 b2
- ^. I1 I, {- q4 u2 N& S* \1
. P e4 {$ c5 W& ]/ f+ n3 Z高阶张量% r' n: c8 y. h! ]
0 H. `1 x$ s! B+ t1 ?, C
你搞个装矩阵的 array 就得到了3阶张量。
2 g, p7 p' E( {" V( I
6 U+ x7 |% y0 ~ i+ K8 A' h! E1 G再搞个装3阶张量的 array 就得到了4阶张量,依次类推,就有高阶张量了。
; i! r, o) x5 Y& O, g& Q+ r; f7 h$ l) [
x = np.array([[[5, 78, 2, 34, 0],
; ^; o! R* |5 J' c$ K) v1 S5 ] [6, 79, 3, 35, 1],
( n: j& }! L+ r J0 M N0 m2 G [7, 80, 4, 36, 2]],
: C0 [7 e, w5 }2 s0 U# T/ T [[5, 78, 2, 34, 0],
1 w$ [, n) D- c: x [6, 79, 3, 35, 1],
) C6 _# m. v# F. j& D [7, 80, 4, 36, 2]],
/ y' O6 F" N& `$ ^% B [[5, 78, 2, 34, 0],$ V$ ^3 C- u/ a. a1 D3 F! l
[6, 79, 3, 35, 1],
6 B6 |. m9 S; R. _ [7, 80, 4, 36, 2]]])" k$ i& h& a! [# S, t
x.ndim! q- c3 f$ G4 M1 w
1, P8 A( r) p6 C& q: [0 a
2' G/ {/ @, t0 o- a, S% | s
3
$ h# ~* S1 E7 W% K A" R4
: J! O" D+ F! a0 ^5 t) O8 h+ s& X5
& b u* { ^2 O) k& U" a7 x8 U+ w2 e$ G6
( M. L1 @; ?& K. _: P2 S7, o- \/ L \( d
87 X3 m7 u; o W% ]% }$ J7 {
9
" g/ ^! A% C) `6 v10
0 Z3 E1 z+ E" b, C# K输出:
/ I# v0 D+ w6 J4 W+ @2 }$ a& y% j& [8 a3 j F
3
# s, u9 R, o" _9 C1' B( z+ g0 D0 o# B
深度学习里,我们一般就用0~4阶的张量。
$ y6 |, Y" A; M. o9 e- \. [1 H7 {, x) p/ H$ \9 _0 L
张量的三要素" f3 S1 i+ _2 c9 A; `. _# O
0 ?6 s6 k* w9 L; w) {' B阶数(轴的个数):3,5,…
6 M( {2 g: F4 I/ r4 y, a形状(各轴维数):(2, 1, 3),(6, 5, 5, 3, 6),…. G/ d6 I2 G% l0 w
数据类型:float32,uint8,…$ u5 E4 x* R/ P' K5 t: {
我们来看看 MNIST 里的张量数据:; y8 J: U1 u, z2 F% B- K5 m9 X+ b
! d: \1 g. w7 \+ e! ~, i1 p* ~: Ffrom tensorflow.keras.datasets import mnist
+ y/ k4 i- G, J9 p2 A; b2 C% N, ^(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
1 ?( g# J' o$ J* ?. h: y
# K3 F5 O6 u& `8 _; ~( _print(train_images.ndim)
( \2 z+ ~5 Q$ m7 s x* F) Yprint(train_images.shape)
5 t( J3 K$ y+ t9 B8 p- {! n% K1 O5 g8 yprint(train_images.dtype)
7 m) g, i7 q+ j1
. X; Y0 o) R5 h2 m1 f2
$ q6 }; q8 v+ T l% q3 r3
9 w1 l8 W* p1 n$ l3 P/ i4
9 ^/ e& N- `) p! |5 l) j3 ]6 r5& f& @) B" q1 H! Y s
6% N% B( K9 N0 x# a: \. U
输出:
; k6 {; p) S. O7 X" l- Y/ p( s* D4 @, r
3
% {: H5 c+ ?6 q(60000, 28, 28)4 q% v1 t, r0 Q; ^0 q4 R
uint8! w! i, ?% G$ v' w5 K/ O
1; h+ h/ r+ d4 @ H4 T/ b# D$ X
2% R% t$ q7 i) w) P( x& a
3
4 F, Z1 i" V! C7 }所以 train_images 是个8位无符号整数的3阶张量。
! B# l) k7 c$ U8 c. }- [
+ L& W7 ~" p0 L" [% W打印个里面的图片看看:7 n8 H1 D1 w' g$ F0 P s8 @" _& [
- |, N; C9 s4 w: S
digit = train_images[0]
+ A! Q0 F& J5 R$ A: t+ ~9 T' g5 }" `5 r' H9 D
import matplotlib.pyplot as plt' r S9 w& w+ P4 { V+ \
5 F/ @ f7 V; a3 }6 M3 X. P
print("image:")
6 p2 q, H% _- n! Z! Mplt.imshow(digit, cmap=plt.cm.binary)
2 o: t+ p% t& k; k5 \plt.show()
: W4 U- p2 n7 D( @! A0 Cprint("label: ", train_labels[0])9 ^5 Q( e. C4 O, L
1
3 s: T! @; R' N2$ r' A. C* b% K
35 ^: P: _+ Z9 c1 N9 A" _
4: r; T9 ~" ~ S9 ^
5( z- a3 s0 G4 ]
6
) j6 S9 ^5 O( ]" A! E7( t5 D0 U$ I4 h' _& Y
8
/ J) k" I& ~5 e6 g8 D, G输出:
6 s8 d/ N4 F; Q v( r9 w" E
" A* k/ e" V3 S {# M4 X0 I5 \
) j, o3 k% d, D- \8 m' s) z) B. g7 i' F- ~4 C3 Z0 \5 {. G
label: 5- t$ h# _% ]) y( F0 [9 r- _& I1 z
1* t; C# P# J; m: i, p* Q; L" E
Numpy张量操作
% ^) t7 j) j l% f" w# I) |
8 U$ @% J0 `8 P3 u e0 E4 p张量切片:7 s) q+ W: F( \ q; z
4 l" @' h( q# E% @. xmy_slice = train_images[10:100]
% V0 C# [+ c1 D3 S, L) P- E7 S+ gprint(my_slice.shape)
s$ D; k3 b" s; X1
. m$ ~% e) d: j* w2
8 `% F/ S3 Q% q/ a! M输出:0 H. Q9 @$ x: s* O( j# S
8 a: c& f/ b' o% O' f7 V(90, 28, 28); @1 k) V. d5 ]+ I+ ` k- B
12 o* c5 F) V V4 v
等价于:8 a6 ~5 [ F' e+ ]
$ J4 x2 |* r* Y& v, E
my_slice = train_images[10:100, :, :]
( H6 z, @5 _9 f/ z7 y, ]" s, gprint(my_slice.shape)2 J. M5 A6 ^1 |1 h6 y _0 k" B
1! @" f, Q6 c7 |$ e5 W7 |# r4 r
22 u% ?4 Q0 D; W x
输出:
+ M$ E; b, F/ m5 B2 A! k
+ b! `! B' ~* s7 m1 q1 q(90, 28, 28)6 {0 Q) S- J J! J# y# C
1
/ F' q o2 `; R+ t也等价于0 C9 y6 J6 Q7 v) Y" L% V
! H( j e) ~0 |4 f$ ?+ J$ G* z( Umy_slice = train_images[10:100, 0:28, 0:28]2 L) m) p% w2 s5 Z# ^5 W8 R. q, H
print(my_slice.shape) _- l( U F4 o$ i
1
6 e, v. z$ ?) I/ v! W t2 g: o+ ~' H8 B& C" T
输出:1 N/ O& R8 Q) R, Z6 h
+ {/ u9 N# G# f! g& m(90, 28, 28)
# y! z/ b0 p$ \* u8 ~( r, j( S18 k) B) }) z- S) z, d' F
选出 右下角 14x14 的:
7 x$ ?6 T [# U' z! U. Y$ _
8 A3 B3 }6 t/ D i9 I$ Emy_slice = train_images[:, 14:, 14:]
4 [' M8 ~% J; n: ^. Oplt.imshow(my_slice[0], cmap=plt.cm.binary)( k9 L1 G, g) ]; M- o* G# x! R5 u
plt.show()2 C5 f4 Y1 S9 Y. k, D: [8 ]1 B: N2 `
1
& z. E. x3 q% d1 w3 s" y2
3 x# @" h5 \) j9 v( U3
* ^4 b3 K$ g: r, P$ T输出:
+ o( z! Z" e' O1 n, Z
4 ]4 s1 I: }9 T" P
' E( l' f' m. O9 O) O1 r0 m6 |5 h1 R" {0 E; n4 ~
选出 中心处 14x14 的:
4 z) B' ~& a! I0 X! Y; S
, d/ A/ ~& d% L( Kmy_slice = train_images[:, 7:-7, 7:-7]
; o W$ F9 n Jplt.imshow(my_slice[0], cmap=plt.cm.binary)) ?/ m8 Z# c O) V
plt.show()
3 X% D) c7 ^, D! {6 P5 y+ _0 W1
6 `- t8 U# M. y( t2 k$ l/ e24 ~6 f/ Q( u, n: y
3
5 W/ Y; F+ L/ R, K$ R5 @输出:- N, x0 N2 M% z% R% g6 K& Y3 M. j
8 x3 D0 e) x7 N' j* F5 e: T, }! }" J- Q, {6 n
& k$ I5 p/ v' n! c# g数据批量$ _0 O0 ]) R3 n5 w
: G% q- j) r$ X! k6 O% `$ x
深度学习的数据里,一般第一个轴(index=0)叫做「样本轴」(或者说「样本维度」)。
7 A' ?. k! @* w% T5 A0 V( f2 H! D) `' {$ z) k; {6 ?& ^
深度学习里,我们一般不会一次性处理整个数据集,我们一批一批地处理。0 H, H* q5 ~8 d' t" o2 J
* z' @+ x- f ]4 d& i在 MNIST 中,我们的一个批量是 128 个数据:
) d7 Z1 k, n) E( V1 F- h! v3 \% R1 [2 y( b+ {
# 第一批. v; [$ H. ^) i `# K! }5 S
batch = train_images[:128]5 [$ n; z( d# C
# 第二批1 I$ V% f+ Z( V! \! N
batch = train_images[128:256]
* g' N, l" {7 M# 第n批
0 ?8 P/ P2 q; Mn = 125 _( z. u/ Z9 N( w
batch = train_images[128 * n : 128 * (n+1)]# c6 k: [. G* l* b; F
1
5 J9 G# Z. \8 l, N2 _2
/ f1 X; }, C4 h& J+ d3
T! e$ z L' R1 w4" a, k; e0 O- n( @3 c( {' n
5
0 F5 f4 \1 v7 y% S6
9 k' i( L8 U6 i. A" u7
& `+ y+ B5 R. \ V% X- t所以,在使用 batch 的时候,我们也把第一个轴叫做「批量轴」。1 v* I5 ]# _% W+ {5 x3 E2 \/ Z: ~
& f2 k4 U& ?# K
常见数据张量表示1 o# h" B i$ ~% U2 O# Z5 v
p* S# h; M. Z7 K9 p. F E
数据 Q% g' c" F8 e+ T* e0 j/ P+ b
|
zan
|