QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 6602|回复: 1
打印 上一主题 下一主题

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

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

5273

主题

82

听众

17万

积分

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

    [LV.4]偶尔看看III

    网络挑战赛参赛者

    网络挑战赛参赛者

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

    群组2018美赛大象算法课程

    群组2018美赛护航培训课程

    群组2019年 数学中国站长建

    群组2019年数据分析师课程

    群组2018年大象老师国赛优

    跳转到指定楼层
    1#
    发表于 2020-5-12 11:55 |只看该作者 |倒序浏览
    |招呼Ta 关注Ta

    0 [$ O: G8 D8 u. Z, e5 ~: w7 BPython深度学习之初窥神经网络
    2 ^5 w7 y+ \0 r5 u本文为 第2章 开始之前:神经网络背后的数学 (Chapter 2. Before we begin: the mathematical building blocks of neural networks) 的笔记整合。$ |! x% T% f' y; _

      ]& g& r9 O; e/ ^# |3 c4 R. z本文目录:. C9 F: O+ x- U8 ]' ^9 [$ |9 D

    " Y6 @# D: P8 M0 |$ E1 Z文章目录
    5 T/ `! b1 _% z" k. M. ^6 G( s, d& v% a" r
    Deep Learning with Python; s$ g, M. x8 |; k  o2 o' w
    初窥神经网络6 `; y5 `7 r, f$ z- R- M
    导入MNIST数据集7 X, V3 z0 V! x! H: N, d
    网络构建5 d+ c* ~, C  H7 q# l1 v
    编译1 _# q/ \! S: C! y% T/ v, }
    预处理( }9 u3 J3 s  g4 Q) {6 m* j
    图形处理
      ?) {9 v3 G! W  z1 F: \* [1 e标签处理
    / O* x& q" ^  u9 k" ?5 c: q% O9 F训练网络
    " A+ l( P1 \- P. {* ^& T神经网络的数据表示/ p8 t- U- ]8 i6 f# |; V
    认识张量
    ! i8 P2 S! H9 z4 N  P6 p标量 (0D Tensors)
    - j3 ?; A  p3 |8 O向量 (1D Tensors): q4 S+ `7 ]% c, n! J, y4 x
    矩阵 (2D Tensors)
    ) q0 I+ _4 Y7 A% N( a: M, s高阶张量
    2 c( u1 q& P6 W0 z8 q+ Y6 {6 l1 f张量的三要素
    ; k: H8 F* J& c. @4 }+ SNumpy张量操作8 [& |* B7 M9 S" Z1 W' Y; D. l
    张量切片:
    6 X1 l$ }6 G. ]1 v: [0 ~+ G数据批量2 i" Z4 n8 m4 j
    常见数据张量表示# B5 x# t8 ]1 b# `- P
    神经网络的“齿轮”: 张量运算
    4 f' a: _! E" c8 m8 Q逐元素操作(Element-wise). G! F% `' M& S3 @; |
    广播(Broadcasting)! B/ j# J( A* ^  `6 u5 s
    张量点积(dot)  c  V* ?* F; ~( v" [
    张量变形(reshaping)
    ! S$ U1 I2 ]5 r神经网络的“引擎”: 基于梯度的优化
    2 M# O$ x( `/ _: W* d: C7 Z导数(derivative)& D# b* Y3 D9 N- F+ B: A
    梯度(gradient)2 u9 h- }8 m2 o0 q' e1 C9 J6 G
    随机梯度下降(Stochastic gradient descent)
    ! v: M' w# l  v/ X( K) Y' O( B3 ^反向传播算法:链式求导' t, d; t  c& Z! \8 L
    本文由 CDFMLR 原创,收录于个人主页 https://clownote.github.io。$ G% |9 {2 F0 U. W: s

    * K) d( X$ h3 k) f/ x* A0 g8 l2 U初窥神经网络. G; w) r$ E( n
    % C# ~: E4 V/ h, p
    学编程语言从 “Hello World” 开始,学 Deep learning 从 MINST 开始。
    . t3 ~( W4 Q# J: f  u) B
    , C( s' }5 k8 |% Q) D3 hMNIST 用来训练手写数字识别, 它包含 28x28 的灰度手写图片,以及每张图片对应的标签(0~9的值)。
    ( y: v  {- Y9 k  ^7 R1 J( T
    ! V/ D/ T! _8 b2 H导入MNIST数据集
    , X2 g" {/ O, s/ Z! a, g' o; k. D. P. q  y; U6 K+ ]
    # Loading the MNIST dataset in Keras' i6 ^5 ~6 V: M  J% N
    from tensorflow.keras.datasets import mnist% w. D7 Z$ n5 i5 @! }! f' G5 u
    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()2 G  H5 X  j4 y6 R6 T
    1
    & p( p! b* I) L  A" x2
    1 Q  x4 Y7 w2 h; @. d7 W3
    $ [3 P& m; P0 J4 _7 b看一下训练集:
    ' S4 r; _* F" Q/ N4 c, `% M* D
    5 j3 a( [6 W/ P7 wprint(train_images.shape)' R# H- z; q1 o
    print(train_labels.shape)
    1 N: P* w( W! x) B3 |" R' H/ m6 `6 ftrain_labels; f( K& Y, E/ m' M6 y: ~9 E
    1
    0 f" }. [. \/ d& Z9 f2. u4 c) t6 ^- Y
    3
    # L9 i( |* H$ q输出:
    : \0 W  M" h* e1 J  D$ Q7 Z. i: E% K3 b3 |: w+ f' e
    (60000, 28, 28)
    " K, i) H. }; z0 `: S(60000,)6 x" H) h5 I  Z% b% I6 F
    ( l0 R! N, u* v- w, n- Z& X* ?
    array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)
    . T! ]7 X  ~8 s4 B6 ~1! D; A2 k; b0 ^2 f$ ?* D
    2% [, I/ P! M6 n' P$ q
    3  Z0 ~2 K3 O1 Y/ M, D/ ^5 H0 j
    40 l' }  h+ V" c5 A9 v
    这是测试集:0 x) P! E& e9 M: u

    ! V0 l" a0 L( Q: R+ T2 O) \* I! v; A3 fprint(test_images.shape); [8 O6 U* T/ a5 [4 |
    print(test_labels.shape)/ W& e' d. t% e
    test_labels2 z7 M9 C# X0 h; B5 e. o! X' `+ t
    1
    & a5 e9 x+ [+ A20 _7 ?3 R  r/ K+ N5 y) s. r/ E
    3/ C* _4 j$ Y' `# s7 l) x
    输出:
    : `- Q9 r; ?3 W$ F+ S; n- p. M6 N( i, M1 Z) n- H6 P4 G
    (10000, 28, 28)$ R4 S5 D6 d$ m& o* J
    (10000,)
    $ _; Y8 n- ^1 [6 I8 {
    # e  K; _8 O3 W9 H0 Y* p$ o* Garray([7, 2, 1, ..., 4, 5, 6], dtype=uint8)
    , M& J4 e4 `6 l) R( q* O14 [2 B  f9 j# k
    29 M6 w; ~$ k3 O2 d! r. o
    38 F  s/ H" p% w! ^+ I
    4% ~+ b' W/ `2 i+ E
    网络构建! D( v# G# T2 W# D7 Z
    & n+ I! j9 n: L9 M
    我们来构建一个用来学习 MNIST 集的神经网络:7 x: @9 n8 D& J, ?* \( C

    3 X6 \! e8 p* I( w" f7 Ofrom tensorflow.keras import models. N" l) y& x" n9 _: A' y$ l
    from tensorflow.keras import layers7 Q- ?  F9 ?% q: n3 }

    * x3 E9 q' o' z8 Y  ?) z4 M) P! Bnetwork = models.Sequential()
    ! h7 I1 R0 k6 Y/ U# anetwork.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))
    ' m" l  h* }9 x' j2 S7 znetwork.add(layers.Dense(10, activation='softmax'))1 `1 G) Y2 P6 y3 b9 C; `; @
    1
    ! U6 C  s- x0 B- ^# W29 s0 i; e( r" U+ R% C
    3% S7 ~9 D/ u  O8 J+ H
    4
    ; M* J$ m, T1 j' b2 R5/ P6 c0 ^$ N0 Q( {2 b  J0 f8 }+ v
    62 E$ {0 {% {; g/ M9 T  S* L
    神经网络是一个个「层」组成的。- O) A, U5 `: t8 j) i+ [
    一个「层」就像是一个“蒸馏过滤器”,它会“过滤”处理输入的数据,从里面“精炼”出需要的信息,然后传到下一层。2 _# `. m% E* l/ z5 r8 x0 X# l
    % v5 G) p, m/ Q* Y
    这样一系列的「层」组合起来,像流水线一样对数据进行处理。
    ' N4 A+ S( G3 h1 J( H1 n5 r( t层层扬弃,让被处理的数据,或者说“数据的表示”对我们最终希望的结果越来越“有用”。
    ' {5 X- d- a1 x& T0 b* D, e+ f) t  R2 f% i& v' o4 y) ?0 ?
    我们刚才这段代码构建的网络包含两个「Dense 层」,这么叫是因为它们是密集连接(densely connected)或者说是 全连接 的。1 X! ]3 R9 E" H/ K
    3 [7 C7 ^, ]& g% q) _; ~
    数据到了最后一层(第二层),是一个 10路 的 softmax 层。, e8 O5 W; H0 X
    这个层输出的是一个数组,包含 10 个概率值(它们的和为1),这个输出「表示」的信息就对我们预测图片对应的数字相当有用了。
    / B/ `, F% E% ?& @9 L7 x事实上这输出中的每一个概率值就分别代表输入图片属于10个数字(0~9)中的一个的概率!& P: s( O0 g8 y5 N& p, M3 ~

    0 S( k9 C; `5 |编译
      r" b2 V0 d5 O) \+ C0 D% z' e
    . o0 w; z9 r0 E; _/ |接下来,我们要 编译 这个网络,这个步骤需要给3个参数:
    0 B2 Z4 ?2 v% Q4 l
    6 d2 s( `- O( u/ A6 w! ~. K损失函数:评价你这网络表现的好不好的函数
    ' B$ _6 r! Q9 @- W: d4 y优化器:怎么更新(优化)你这个网络
    6 I0 I% N/ u7 F9 b* N! g训练和测试过程中需要监控的指标,比如这个例子里,我们只关心一个指标 —— 预测的精度
    & ^) D% ~% I  I1 unetwork.compile(loss="categorical_crossentropy",- F  K  I9 ]$ R9 ^  H9 b
                    optimizer='rmsprop',
    0 e. j: M( M- m' e8 r2 T, O                metrics=['accuracy'])
    * \0 r( `) I/ n9 Z5 A! p: i! S  G1( \+ V4 _. f) N3 z, f- \0 M# L1 c
    2
    ( W4 \& C( D. `7 F3
    7 `# a6 L2 m3 k) y% ?8 k, N预处理; B' @7 T2 D  M9 l6 @3 E: n* N0 o

    ( F( e; {# l7 O) c% W$ o图形处理: G9 p" M! M+ m6 e6 @

    * x- Z6 y1 d  r: {, a, @1 s我们还需要处理一下图形数据,把它变成我们的网络认识的样子。
    - R' j5 F% ^; U9 C5 |$ _- a5 {* D# p! x& T! A. x2 K8 X. e) _
    MNIST 数据集里的图片是 28x28 的,每个值是属于 [0, 255] 的 uint8。
    ! L7 z# B1 x% a8 I而我们的神经网络想要的是 28x28 的在 [0, 1] 中的 float32。) [+ s1 G9 C  d. j8 x1 t

    , E0 w7 W$ W4 Q* I8 a5 t& y+ _- jtrain_images = train_images.reshape((60000, 28 * 28))
    " _2 c. d& Q4 R4 v5 c. u! W* ?train_images = train_images.astype('float32') / 2556 y$ Y3 }$ q! p5 p+ V- H
      x0 u3 Z8 F; o' _& P1 o- N# f# @
    test_images = test_images.reshape((10000, 28 * 28))3 E) i* W- |) ?( Y9 t, w
    test_images = test_images.astype('float32') / 255- i. f9 j& u+ T1 w% S2 }
    15 J. p: `( d- a- |/ w8 `
    2
    ' l( m; `' h, N5 D3 [3
    ; B( {  y5 M' _) r& Y8 m, G& }4! t$ [8 X3 v1 T' h& x: M/ H
    5
    4 C, z' ~( C' ]4 I  n标签处理
    2 u& P6 P* d$ U1 L
    6 {% A' ?; R; x同样,标签也是需要处理一下的。
    ) ^: l, w' {( q
    ' C' l" h; x9 j3 B3 K/ U$ |2 J, t$ Tfrom tensorflow.keras.utils import to_categorical/ x9 O9 X- n* e+ p- o) d
    # g' n' E1 o. K6 Q# Z+ E
    train_labels = to_categorical(train_labels); t! h& [. P: w* ]
    test_labels = to_categorical(test_labels)7 a# W5 y, T; O2 ]" v1 U
    1
    5 a# y1 l. C* P4 \2
    $ Q: }. X8 q- f$ G) P  n% ^# N1 t  v3
    ! u: \8 _* b1 j  i( D0 Y4 n* _4
    9 m, ^/ L, g& v! V- o# j训练网络5 P* i: r3 R  [
    ' p2 g1 q: i4 \3 g9 V5 m
    network.fit(train_images, train_labels, epochs=5, batch_size=128)
    / b: z" E! \: }* A1 S$ E: l3 i1 {1% D; u* ?  r" v8 |9 y- e
    输出:
    # f$ \1 \& o/ ]% m) x( {2 {
    0 E# B$ b& ^+ r3 [, D; pTrain on 60000 samples8 H, m6 `( L3 F
    Epoch 1/5
    7 G) N, k. i: }' b/ }& q60000/60000 [==============================] - 3s 49us/sample - loss: 0.2549 - accuracy: 0.9254
    / F' U0 r  k: o1 z) J* v! W+ c( V$ |Epoch 2/5
    ( T# |0 L6 g- ~60000/60000 [==============================] - 2s 38us/sample - loss: 0.1025 - accuracy: 0.96936 @2 c# ^, V) M* c. n
    Epoch 3/5. ^  p5 L; h2 {, x! {  ~
    60000/60000 [==============================] - 2s 35us/sample - loss: 0.0676 - accuracy: 0.9800
    % {; _1 u5 i  dEpoch 4/5
    & A* x; x$ C3 ]0 |% l60000/60000 [==============================] - 2s 37us/sample - loss: 0.0491 - accuracy: 0.9848
    6 s9 e' d0 ]' j/ `3 d: J8 g/ UEpoch 5/5
    " c; p; i) c$ s7 F7 Q  x; }' v60000/60000 [==============================] - 2s 42us/sample - loss: 0.0369 - accuracy: 0.9888+ @* J* C2 s3 S% Q/ @+ R
    - H; e1 t6 k  J: n
    <tensorflow.python.keras.callbacks.History at 0x13a7892d0>! F; s) A! s1 @. n4 w
    1
    , s0 K. q( Y7 B8 ~& ]5 P27 L9 D- s3 a9 V6 r" e; @% A
    30 g7 `/ R0 ]) B9 U
    4: @" q% ?% P9 O0 j2 `. h: k! t" E! l
    5
    & _# {* [) {5 K5 p& R, \& I6
    5 G6 [1 c8 k2 b7
    : g. y: e7 r( ?5 y8
    + a( ]1 x" z9 S2 Y8 i92 O0 W5 K2 g9 ?8 j+ z" F9 m
    10* v$ z7 _2 v! C9 a" G% k; z5 z
    11
    1 q% R6 u. e8 k* t12
    ! A; j+ W" l7 |4 |* q/ Z13" i& ^% @) l6 W4 u  V2 v
    可以看到,训练很快,一会儿就对训练集有 98%+ 的精度了。2 U+ G$ E+ @* u! ~

    ( J( I" E+ L: D再用测试集去试试:
    , |  q/ w9 |- c. H, p) ]$ j& g4 M; Z
    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
    2 }2 o1 F8 k# ]; _2 Nprint('test_acc:', test_acc)
    2 A! }/ Y2 T" K1
    " Z( }, Y2 g) b& b0 l2
    % x- q; x$ y; T! d+ p0 y  I输出:' G' a) b9 v2 E9 ^, F0 M& e
    ! Q  C! W! T8 n+ _4 z
    10000/1 - 0s - loss: 0.0362 - accuracy: 0.9789! n1 G8 }' S* d, X
    test_acc: 0.9789  S3 `8 `0 R" ^2 {; J
    14 d. h- V! k: L  _( N- i
    2# `- f2 H6 R* y  q6 R/ P, W) V
    我们训练好的网络在测试集下的表现并没有之前在训练集中那么好,这是「过拟合」的锅。+ N6 d" w$ e$ f0 p; r
    + W( M: M" }) ~- \% J9 w
    神经网络的数据表示
    ) q# \6 F9 b) {* @1 m* [, T+ c0 b5 [7 @& ?* Y. k2 j5 M
    Tensor,张量,任意维的数组(我的意思是编程的那种数组)。矩阵是二维的张量。
    ! g$ i, p8 Q8 t- A
    ; Y) f7 _; A0 y8 m# c我们常把「张量的维度」说成「轴」。# w" [% S5 S3 K3 W
      Y, M0 p0 o2 {% l
    认识张量
    . m/ }, r- u% ?2 C( i; j" A7 c7 L- z, }* A
    标量 (0D Tensors)
    % |$ r1 [9 k. k& j0 q
    . W! Z, q* A/ ]Scalars,标量是 0 维的张量(0个轴),包含一个数。
    & ^( G+ c& e5 N, N, U+ ]) c2 d/ ~) J; ]6 a* Q. o7 d
    标量在 numpy 中可以用 float32 或 float64 表示。) R( S7 y6 t* e; V5 A) L  l
    3 c* i$ _* Z( W! x" C. N
    import numpy as np% C; V5 R& w1 C8 x/ A
    + H2 [# H! I( e& a) w6 w  H* p  y
    x = np.array(12)
    % T5 t5 G  W2 c" X' q) Kx
    7 \. i- H9 v# D; `6 |14 i: r, K9 f: Q. ^+ q
    2
    9 ]9 |5 ^; S) P! `+ V7 [3
    ) M+ V9 c# s" j* r( X4 O9 M4
    ; H) d) J6 H$ Q输出:
    3 h1 Y) \/ |, _& I1 `: ^, o% _' C$ M/ q/ e, n6 R- r
    array(12)4 d) E( Y4 G& K! @6 x& P' N
    1
    ! C, U2 i* R, ~: J3 Zx.ndim    # 轴数(维数), l* t" \6 R) O; H( v$ \6 a
    17 f3 i1 c. t% v7 ^. {
    输出:2 F4 U* l; j+ ?2 }' X  u

    2 {' e) b7 s6 |/ G! f1 E! }. a1
    ( A6 @! P5 J: _0 Y) R1
    : b2 G! n. Z( n0 l3 O向量 (1D Tensors)5 |! {( K; s" k+ a
    # _2 c$ Q" k- r2 ?- Y
    Vectors,向量是 1 维张量(有1个轴),包含一列标量(就是搞个array装标量)。9 z. k/ _1 {& s$ x1 q2 [) q

      x$ q% E9 u( nx = np.array([1, 2, 3, 4, 5])
    0 j) N+ s5 _: ^1 {& [1 x* l5 R) dx
    ' b1 ?4 L8 o/ X; U; w( P# P1  W5 ~( D' ?: ^. n0 M
    2  g, {9 \' F( b5 |% `; S
    输出:
    3 D4 ]4 w$ v3 v$ j3 X. h4 `; R; @( \& P( p- B7 I/ n
    array([1, 2, 3, 4, 5]), T$ t& C  U' S% {( e- O* B
    16 Q" z" K: p/ B4 K  u
    x.ndim; w4 }; F2 |3 R& \
    1) j$ p  I4 v  V5 ^! `2 a
    输出:
    " W5 j6 ?' Q2 T* {( {! Y& I4 R. V6 j
    1- E' s2 p) R! n1 z* S/ h
    1
    ; B, C$ A1 |2 j2 L0 Q: l: M我们把这样有5个元素的向量叫做“5维向量”。+ |' U/ _4 ?; s
    但注意5D向量可不是5D张量!
    0 C1 J% g! W6 ]$ O7 H; l9 V- o
    1 n4 g+ X- u! \% c: Q5D向量:只有1个轴,在这个轴上有5个维度。4 c+ [5 j9 o" v/ _- r
    5D张量:有5个轴,在每个轴上可以有任意维度。
    : I$ }, [4 y: M# x1 ^% S1 d这个就很迷,这“维度”有的时候是指轴数,有的时候是指轴上的元素个数。- e/ f) B) g: r) y; c
    5 i/ A, v) X. |  h" l
    所以,我们最好换种说法,用「阶」来表示轴数,说 5阶张量。+ V% y+ c) s/ R0 U/ E* t
    , k* o% D1 Q5 O
    矩阵 (2D Tensors)
    1 X' |" v" V3 ^. m
    " m3 _* O" w2 ?  B# k# c! J2 kMatrices,矩阵是 2 阶张量(2个轴,就是我们说的「行」和「列」),包含一列向量(就是搞个array装向量)。' A. v: w/ ~$ o) C0 h
    $ E0 W5 y1 @' N" w! i
    x = np.array([[5, 78, 2, 34, 0],
    0 u2 k6 ~" N- s0 X5 _% `& T9 [              [6, 79, 3, 35, 1],
    ! d7 O* ^9 c4 Y2 \  A6 c" g; ?              [7, 80, 4, 36, 2]])
    ! [, w" F9 c" b7 Qx
    4 ]' ^4 F4 _6 S. K7 g7 L1* l% d# Q& I/ n1 S; K8 h4 _
    2
    $ w5 \+ h! H4 Z& O3! ]2 K* h  p/ T, Y7 ^
    4
    ; D2 ~7 ~5 x) _* D/ v! u& ^: X输出:' B* A6 l. z! [) W7 }7 t4 Z9 \* z
    9 v4 C. A6 n( r5 D* W; ~) H! ?. V
    array([[ 5, 78,  2, 34,  0],
    : A, Z, b! S7 \- L( a9 p       [ 6, 79,  3, 35,  1],5 C! W) S; _) D
           [ 7, 80,  4, 36,  2]])) p. L' [5 @2 _4 v
    1; d( D$ E  u: e
    2
    ) q6 x! w# o5 O% m3 p1 o* y# u. @3" X4 {$ `& N) B6 K5 J
    x.ndim2 |% l2 b6 d& C$ P
    10 ?4 T* o; z) T/ I2 r" F1 [1 e$ e
    输出:
    / d0 y0 ~' P( _+ n( z$ C4 Q6 F& `1 c) Y
    25 X& S+ G+ e. y: y8 {, t4 @
    1
    3 V- h6 K, F1 ?/ o6 ~  d, Y" n  f  {  _" o高阶张量
    8 c4 `- {2 b" J
    3 {; u$ P( Y3 Q0 t1 |+ n! P: R你搞个装矩阵的 array 就得到了3阶张量。. a/ p. |/ J- t- G2 W( @
      g0 P$ f2 }5 T8 l1 ^+ o9 D
    再搞个装3阶张量的 array 就得到了4阶张量,依次类推,就有高阶张量了。
    ! A4 g( @9 H3 Y  H/ X5 t" I1 S2 u% l8 H8 a% a' S- B
    x = np.array([[[5, 78, 2, 34, 0],
    8 {, ^0 J. n3 H' F               [6, 79, 3, 35, 1],
    . E. ]! z) S1 y8 H) c4 R               [7, 80, 4, 36, 2]],8 V5 O4 J- d6 `/ k8 q) i( `1 [
                  [[5, 78, 2, 34, 0],
    $ t$ L$ b: ?6 H) F8 P               [6, 79, 3, 35, 1],& \9 V/ g- W) e7 ^% U/ i
                   [7, 80, 4, 36, 2]],
    3 d# y6 j6 d, n  H' ?' @  D$ O, E              [[5, 78, 2, 34, 0],3 b1 `  d# `" b+ \( I$ x5 X
                   [6, 79, 3, 35, 1],
    $ z7 E3 l# l6 |- K               [7, 80, 4, 36, 2]]])9 B0 W8 W$ g+ \5 A9 n) B' Y# D5 R, J
    x.ndim
    9 T5 B! |6 x8 s1
    $ b2 N( v' j2 M! I2
    * ?# N! H: v# @( `( I6 }* u3
    - U2 S" D, F* t+ s9 Z: p4
    8 v# p2 q+ ^' a3 ^5+ d3 u* A. w1 t7 m& Q: h
    6. M3 _4 U! [% Y' Y
    7
    & r5 G/ Q+ t& x$ u8
    5 I$ Q* g5 e  ^8 Z9- S8 Z, j4 c- r2 R& v5 }. P
    10
    5 P) Z% @  Y+ `2 t* a' X6 b$ ?输出:4 i; g. ^0 K. {) C1 U, s
    " `  @5 Z" C9 r& S+ x: o( e" K
    3
    1 b' a  a" {9 X- X# h( ~( M1: m! a! N' B, ~; O  ^& V: }! ~
    深度学习里,我们一般就用0~4阶的张量。& N- }" |8 u2 ~" }
    6 b2 \! ]9 o  E! c$ T, ?) s" ^8 f
    张量的三要素: e0 z2 }  m4 ]+ }7 H0 C3 d% {

    1 x/ V+ S: V6 K6 \阶数(轴的个数):3,5,…# c8 F- ~+ P# _  N9 q; b4 Y( d
    形状(各轴维数):(2, 1, 3),(6, 5, 5, 3, 6),…! ?3 T5 L$ G( m2 v2 |: t3 e9 {1 v# i+ A
    数据类型:float32,uint8,…
    ; y5 {2 ?4 h; q( V) m. p: \7 S$ |我们来看看 MNIST 里的张量数据:5 C4 d+ ]* [, \: t5 J4 o" M% g% i
    5 H1 G* L& b# h# h( a* F4 x
    from tensorflow.keras.datasets import mnist! ?$ W% b) z* ?" q# s; ~
    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()" I+ _, v! I$ `6 N) f1 h5 {) S
    1 p) ]6 T: M) |& d; y: H
    print(train_images.ndim)
    6 F5 B- h; o8 o4 Pprint(train_images.shape)  C# S6 F! C% p
    print(train_images.dtype)
    + V/ c; S( Q  E7 S/ K1% z6 F# D; O- l' q: z" }9 k; s% v
    2
    2 `! v% W' I( U" c* o. i% \0 U6 L30 ~8 u; w1 O: F8 ^  d0 C
    4: Y! T' X( q: |: g! T( N4 U. |
    58 R+ Q* T4 O9 `* |! v  T. \, P
    6& o# r; ]$ G( `6 h  S5 u
    输出:0 L2 K* `9 a4 i# w& O$ c3 n3 R: Y
    8 z! f# m9 V) W
    3
    4 \5 V& F, ~7 K+ O' q9 w6 T% a(60000, 28, 28)
    $ f/ H6 {0 Q& A; |; tuint8
    , C; W* l; z: I1
    6 }+ F* e# ~) F  x0 Q  ]2
    9 o+ Z# A: d$ `; h  g! I3
    + B5 [! P& Q" C" H& t6 ?7 E所以 train_images 是个8位无符号整数的3阶张量。4 Q- l( N3 d& I' f. q
    " y( f# d9 v5 n
    打印个里面的图片看看:  C# S; T% b- K
    + W- a8 M' [* ]: f4 {+ F
    digit = train_images[0]
    3 C. H# T3 `8 i! I& Y# I# u. q. o. I6 \7 K$ m
    import matplotlib.pyplot as plt3 b  `5 I$ S3 C3 X! N3 B. \8 w

    7 }8 _" M5 w* ]3 B5 `print("image:")6 T  l  h, C. v4 A0 |8 e1 ^2 y
    plt.imshow(digit, cmap=plt.cm.binary)
    5 n7 y3 [8 d0 \+ f  s" u2 p" a4 S# Eplt.show(). x4 Q) s7 B' e* C# u" S$ U# s& V$ \
    print("label: ", train_labels[0])8 [/ s; S  M3 [- ~/ ?1 U) ^
    1
    ( U6 C) F! p# z+ ]; \. D2
      J' E3 Y$ l2 C  g' N9 a* L# V3) m7 c2 Q! n8 ]" U
    4
    ; F# w4 c# m% J5
    ; a/ z. j9 ^! ~: r9 r; d6
    * g" ^, U* O/ f7 {: y7' [$ H" _  |! \! \
    8
    & }) Z& Q* {/ a% I$ [输出:0 f! b% o# `7 }: B# O+ w- j5 g& O
    $ ~$ [- P- M9 O- P4 x
    1.jpg + P  @0 K- G$ A8 Y% \( v

    % r; ~) @+ j/ w* B  Ilabel:  5+ B! y- }/ F: h7 S' z
    13 V. t0 E, x  g" W6 V
    Numpy张量操作
    ( I' P. \( k% k( c+ }7 G! F; W
    2 G) a' E# D: l1 L: E张量切片:
    1 [1 G4 n( L; g4 X& P3 x( J6 `2 f# [) Z, I3 g" N  f
    my_slice = train_images[10:100]+ Y5 a8 C( a9 E9 ^# X
    print(my_slice.shape)6 k% V" W3 V+ k) R) d4 L' M
    1) I2 C$ ^' q# R7 H9 u, F/ L( D
    2, ~4 X4 A7 \' S, b) m
    输出:6 W5 i# l5 Q* M  e" x* n7 a  k8 ^
    2.jpg
    , Q( Z8 H  i* X(90, 28, 28)
    $ y* i9 U, ^$ z) Q10 s0 Q" y/ h  a$ d' `) z* C- i
    等价于:
    , {1 N$ S/ ?* {4 `; Y, Q& Z& \# J, T9 I$ v. E) H) K( U! D5 [
    my_slice = train_images[10:100, :, :]
    6 V5 @1 {# s9 u) iprint(my_slice.shape)
    : V  ?5 R& ^0 J1
    & V" z7 s  G, T" F21 W3 ]$ T7 d* z$ U# q
    输出:
    - E" k6 _+ b+ m9 c 3.jpg 6 m- X9 l1 _% T. H' F
    (90, 28, 28)
    6 z- L' E1 ^. v& W1( Z: K, J- X, F6 u
    也等价于
    6 v9 N7 [: {$ r4 K+ `$ a" H1 J# j' ?! V; C2 x
    my_slice = train_images[10:100, 0:28, 0:28]' D/ _7 O; f+ T5 ~
    print(my_slice.shape)
    6 Q3 C: ~' |$ N) m. T4 p1
    + V, }: K+ E8 q1 r+ C25 j) o% d6 E; \2 H
    输出:
    6 e, k, m8 a' n4 _
    4 e0 T0 M. H( p8 v( ^0 n" s) M(90, 28, 28)! F6 G) a( @0 Q
    1
    5 w, y5 T! J# P8 M选出 右下角 14x14 的:
    2 A( j- e& f( p5 O2 S( K  o/ Y& b0 v3 O
    my_slice = train_images[:, 14:, 14:]
    ! m( h2 d+ H" [" G, ^" q; L$ G# jplt.imshow(my_slice[0], cmap=plt.cm.binary)
    ! c, c. v. O6 ^4 O9 [, V2 oplt.show()7 {7 [- O5 }0 `$ c, y6 y  o
    1
    3 J, m: ?3 `6 r2 ?8 b( Y9 n( L2
    / W* a+ {: L" ]3 n3) m; J0 O7 q7 A1 \# I+ `: G
    输出:8 P" }  E' D2 R! U

    7 R" D. F$ `* K4 H& S& H2 n: H/ E

    - C2 c! Q# U% M9 F7 `/ O1 X) F选出 中心处 14x14 的:: Y& @: O$ X. [1 G! k* L* y
    ' g2 }# r+ R" T1 K; W! D6 @# N
    my_slice = train_images[:, 7:-7, 7:-7]
    - x2 ^2 E% \1 o$ j3 C+ Dplt.imshow(my_slice[0], cmap=plt.cm.binary)
    1 t  Y) g( W% a. @+ {plt.show()7 j7 ?- z+ T9 O- o
    1
    , w4 F6 n! ^' ^. n; f  n2
    6 M. v. h5 D) U3 o( [& J& \2 r3
    9 @) r, {: n5 P  Z0 T输出:
    / v' R9 v7 c( ?# ?5 }* l! w
    # o' s% J& p8 C& O8 m, @
    / ]5 c: o% T. _" F* C% m/ i
    9 v% U& N7 v- Z+ c- N, m数据批量( ]: m! I0 D! h4 U
    5 ?9 A) O" H; k; Y4 N+ H; w6 l
    深度学习的数据里,一般第一个轴(index=0)叫做「样本轴」(或者说「样本维度」)。* @4 Y+ G, B" m8 z1 Z6 V' k- L" @" N
    $ y+ L4 f3 O7 C7 Y9 Z- o) y: X
    深度学习里,我们一般不会一次性处理整个数据集,我们一批一批地处理。
    . Q5 ]" S$ D: \+ ?$ _! P9 ~& a/ J& ?# m1 G" O
    在 MNIST 中,我们的一个批量是 128 个数据:
    " u+ f5 v  V6 U: `1 ~, l/ d: T
    , U0 ?% v- K0 G2 i  R, o2 e; G# 第一批
    9 _% `8 |8 n4 ?8 G  Mbatch = train_images[:128]
    : p2 T3 l. a( |: S# 第二批
    7 s3 ~# O2 k% y0 w1 c: |$ ~% _batch = train_images[128:256]
    & S& }2 x. N8 P3 e( c# 第n批
    , a) ]& Y! Y4 ~/ q5 sn = 12+ M0 A" o  Z* E7 ~  `
    batch = train_images[128 * n : 128 * (n+1)]0 N3 f# ^  A2 w) h
    1
    ' G3 a5 h1 k) M, v+ Y5 H& K5 b$ o21 F* |& `% @3 X6 A
    3
    ) I- b( ]7 y$ t% t: ]9 s: ^4& e# }) H2 }: r- F  M
    5- V( X) @5 R$ Y* m3 p
    6( U- K7 _. S, t, T  h
    7" e' g+ O. h! g; L# `9 c7 `- u
    所以,在使用 batch 的时候,我们也把第一个轴叫做「批量轴」。! h& w! B% b$ U) l4 v+ |# v' T
    4 r! G$ f. d, Q* e1 H( Z( P
    常见数据张量表示% M2 a4 o. @9 H, r8 x" w
    ( f9 q# u0 G; B5 t4 W- ~- ~' N
    数据
    % I, m% r# Q) M$ \- k* z
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信

    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, 2026-9-2 15:20 , Processed in 0.424323 second(s), 59 queries .

    回顶部