请选择 进入手机版 | 继续访问电脑版

QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 4129|回复: 1

Python深度学习之初窥神经网络

[复制链接]
字体大小: 正常 放大
杨利霞        

5250

主题

81

听众

16万

积分

  • TA的每日心情
    开心
    2021-8-11 17:59
  • 签到天数: 17 天

    [LV.4]偶尔看看III

    网络挑战赛参赛者

    网络挑战赛参赛者

    自我介绍
    本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。

    群组2018美赛大象算法课程

    群组2018美赛护航培训课程

    群组2019年 数学中国站长建

    群组2019年数据分析师课程

    群组2018年大象老师国赛优

    发表于 2020-5-12 11:55 |显示全部楼层
    |招呼Ta 关注Ta
    + }" 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 1.jpg
    ! 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 2.jpg
    # |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" {
    3.jpg

    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

    69

    主题

    3

    听众

    661

    积分

    升级  15.25%

  • TA的每日心情
    开心
    2020-9-13 05:34
  • 签到天数: 149 天

    [LV.7]常住居民III

    网络挑战赛参赛者

    群组2013认证赛C题讨论群组

    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2024-3-29 10:12 , Processed in 0.330562 second(s), 59 queries .

    回顶部