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

QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 4128|回复: 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

    # 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 \ 1.jpg

    ) 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
    2.jpg

    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 3.jpg

    + 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

    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-28 18:14 , Processed in 0.333016 second(s), 59 queries .

    回顶部