动手学深度学习(TF2 版)_第2章 预备知识

最新推荐文章于 2021-11-04 16:39:54 发布
最新推荐文章于 2021-11-04 16:39:54 发布
阅读量232 收藏
点赞数
分类专栏： # TensorFlow
原文链接：https://github.com/TrickyGo/Dive-into-DL-TensorFlow2.0/tree/master/docs/chapter02_prerequisite
版权

第二章 预备知识

查看tf版本

import tensorflow as tf

print(tf.__version__)
# 2.4.0

2.2 数据操作

2.2.1 创建tensor

""" 先介绍tensor的最基本功能，我们用range函数创建一个行向量。"""
x = tf.constant(range(12))

print(x.shape)
# (12,)

# 一个tensor实例，其中包含了从0开始的12个连续整数。
print(x)
# tf.Tensor([ 0  1  2  3  4  5  6  7  8  9 10 11], shape=(12,), dtype=int32)

# 通过len得到tensor实例中元素（element）的总数
print(len(x))
# 12

"""下面使用reshape函数把行向量x的形状改为(3, 4)，也就是一个3行4列的矩阵，并记作X。除了形状改变之外，X中的元素保持不变。"""
# 也可写成x.reshape((-1, 4))或x.reshape((3, -1))。由于x的元素个数是已知的，这里的-1是能够通过元素个数和其他维度的大小推断出来的。
X = tf.reshape(x, (3, 4))
print(X)
# tf.Tensor(
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]], shape=(3, 4), dtype=int32)

"""接下来，我们创建一个各元素为0，形状为(2, 3, 4)的张量。实际上，之前创建的向量和矩阵都是特殊的张量。"""
X0 = tf.zeros((2, 3, 4))
print(X0)
# tf.Tensor(
# [[[0. 0. 0. 0.]
#   [0. 0. 0. 0.]
#   [0. 0. 0. 0.]]
#
#  [[0. 0. 0. 0.]
#   [0. 0. 0. 0.]
#   [0. 0. 0. 0.]]], shape=(2, 3, 4), dtype=float32)

"""类似地，我们可以创建各元素为1的张量。"""
X1 = tf.ones((3, 4))
print(X1)
# tf.Tensor(
# [[1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]], shape=(3, 4), dtype=float32)

"""也可以通过Python的列表（list）指定需要创建的tensor中每个元素的值。"""
Y = tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(Y.shape)  # (3, 4)
print(Y)
# tf.Tensor(
# [[2 1 4 3]
#  [1 2 3 4]
#  [4 3 2 1]], shape=(3, 4), dtype=int32)

"""随机生成tensor中每个元素的值。下面我们创建一个形状为(3, 4)的tensor。它的每个元素都随机采样于均值为0、标准差为1的正态分布。"""
# X2 = tf.random.normal(shape=[3, 4], mean=0, stddev=1)
X2 = tf.random.normal(shape=(3, 4), mean=0, stddev=1)  # 这两种都可以·    1m
print(X2)
# tf.Tensor(
# [[-0.6286057  -1.5282005   2.149251   -0.5682216 ]
#  [ 0.03127453  0.5830824   0.6466156  -0.5903981 ]
#  [ 0.05115638 -1.6249142  -1.1675135  -0.78749204]], shape=(3, 4), dtype=float32)
print('###' * 30)

2.2.2 运算

print(X)
# tf.Tensor(
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]], shape=(3, 4), dtype=int32)
print(Y)
# tf.Tensor(
# [[2 1 4 3]
#  [1 2 3 4]
#  [4 3 2 1]], shape=(3, 4), dtype=int32)
print(X + Y)  # 按元素加法：对应位置相加
# tf.Tensor(
# [[ 2  2  6  6]
#  [ 5  7  9 11]
#  [12 12 12 12]], shape=(3, 4), dtype=int32)

print(X * Y)  # 按元素乘法：对应位置相乘
# tf.Tensor(
# [[ 0  1  8  9]
#  [ 4 10 18 28]
#  [32 27 20 11]], shape=(3, 4), dtype=int32)

print(X / Y)  # 按元素除法：对应位置相除
# tf.Tensor(
# [[ 0.    1.    0.5   1.  ]
#  [ 4.    2.5   2.    1.75]
#  [ 2.    3.    5.   11.  ]], shape=(3, 4), dtype=float64)

Y = tf.cast(Y, tf.float32)  # 类型转换：dtype=int32 --> dtype=float32
print(Y)
# tf.Tensor(
# [[2. 1. 4. 3.]
#  [1. 2. 3. 4.]
#  [4. 3. 2. 1.]], shape=(3, 4), dtype=float32)
print(tf.exp(Y))  # 按元素做指数运算：对应位置做指数运算
# tf.Tensor(
# [[ 7.389056   2.7182817 54.598152  20.085537 ]
#  [ 2.7182817  7.389056  20.085537  54.598152 ]
#  [54.59815   20.085537   7.389056   2.7182817]], shape=(3, 4), dtype=float32)

"""
除了按元素计算外，我们还可以使用matmul(matrix multiply)函数做矩阵乘法。下面将X与Y的转置做矩阵乘法。
由于X是3行4列的矩阵，Y转置为4行3列的矩阵，因此两个矩阵相乘得到3行3列的矩阵。
"""
Y = tf.cast(Y, tf.int32)
print(tf.matmul(X, tf.transpose(Y)))
# tf.Tensor(
# [[ 18  20  10]
#  [ 58  60  50]
#  [ 98 100  90]], shape=(3, 3), dtype=int32)

"""
也可以将多个tensor连结（concatenate）。
下面分别在行上（维度0，即形状中的最左边元素）和列上（维度1，即形状中左起第二个元素）连结两个矩阵。
可以看到，输出的第一个tensor在维度0的长度（ 6 ）为两个输入矩阵在维度0的长度之和（ 3+3 ），
       而输出的第二个tensor在维度1的长度（ 8 ）为两个输入矩阵在维度1的长度之和（ 4+4 ）。
"""
print(tf.concat([X, Y], axis=0))
# tf.Tensor(
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [ 2  1  4  3]
#  [ 1  2  3  4]
#  [ 4  3  2  1]], shape=(6, 4), dtype=int32)

print(tf.concat([X, Y], axis=1))
# tf.Tensor(
# [[ 0  1  2  3  2  1  4  3]
#  [ 4  5  6  7  1  2  3  4]
#  [ 8  9 10 11  4  3  2  1]], shape=(3, 8), dtype=int32)

"""
使用条件判断式可以得到元素为0或1的新的tensor。
    以X == Y为例，如果X和Y在相同位置的条件判断为真（值相等），那么新的tensor在相同位置的值为1；反之为0。
"""
print(tf.equal(X, Y))
# tf.Tensor(
# [[False  True False  True]
#  [False False False False]
#  [False False False False]], shape=(3, 4), dtype=bool)

"""对tensor中的所有元素求和得到只有一个元素的tensor。"""
print(tf.reduce_sum(X))
# tf.Tensor(66, shape=(), dtype=int32)

X = tf.cast(X, tf.float32)
print(tf.norm(X))  # 各元素平方和的开方，即L2范数
# tf.Tensor(22.494444, shape=(), dtype=float32)

2.2.3 广播机制

# 前面我们看到如何对两个形状相同的tensor做按元素运算。
# 当对两个形状不同的tensor按元素运算时，可能会触发广播（broadcasting）机制。
# 广播（broadcasting）机制：先适当复制元素使这两个tensor形状相同后再按元素运算。

A = tf.reshape(tf.constant(range(3)), (3, 1))
B = tf.reshape(tf.constant(range(2)), (1, 2))
print(A)
# tf.Tensor(
# [[0]
#  [1]
#  [2]], shape=(3, 1), dtype=int32)
print(B)
# tf.Tensor([[0 1]], shape=(1, 2), dtype=int32)

"""
A和B分别是3行1列和1行2列的矩阵，
如果要计算A + B，那么A中第一列的3个元素被广播（复制）到了第二列，而B中第一行的2个元素被广播（复制）到了第二行和第三行。
如此，就可以对2个3行2列的矩阵按元素相加。
"""
print(A + B)
# tf.Tensor(
# [[0 1]
#  [1 2]
#  [2 3]], shape=(3, 2), dtype=int32)

2.2.4 索引

"""截取了矩阵X中行索引为1和2的两行"""
# 在tensor中，索引（index）代表了元素的位置。tensor的索引从0开始逐一递增。
# 例如，一个3行2列的矩阵的行索引分别为0、1和2，列索引分别为0和1。
# 在下面的例子中，我们指定了tensor的行索引截取范围[1:3]。依据左闭右开指定范围的惯例，它截取了矩阵X中行索引为1和2的两行。

print(X[1:3])
# [[ 4.  5.  6.  7.]
#  [ 8.  9. 10. 11.]], shape=(2, 4), dtype=float32)

"""我们可以指定tensor中需要访问的单个元素的位置，如矩阵中行和列的索引，并为该元素重新赋值。"""
X = tf.Variable(X)  # Variable是可更改的，而Tensor是不可更改的https://blog.csdn.net/u013841196/article/details/82960765
print(X[1, 2].assign(911))
# <tf.Variable 'UnreadVariable' shape=(3, 4) dtype=float32, numpy=
# array([[  0.,   1.,   2.,   3.],
#        [  4.,   5., 911.,   7.],
#        [  8.,   9.,  10.,  11.]], dtype=float32)>

"""当然，我们也可以截取一部分元素，并为它们重新赋值。在下面的例子中，我们为行索引为1的每一列元素重新赋值。"""
print(X[1:2, :].assign(tf.ones(X[1:2, :].shape, dtype=tf.float32) * 120))
# <tf.Variable 'UnreadVariable' shape=(3, 4) dtype=float32, numpy=
# array([[  0.,   1.,   2.,   3.],
#        [120., 120., 120., 120.],
#        [  8.,   9.,  10.,  11.]], dtype=float32)>

2.2.5 运算的内存开销


"""查看操作新开的内存"""
X = tf.Variable(X)
Y = tf.cast(Y, dtype=tf.float32)
before_id = id(Y)
Y = Y + X
now_id = id(Y)
print(before_id, now_id, before_id == now_id)
# 2145964333192 2145964333368 False

"""
如果想指定结果到特定内存，我们可以使用前面介绍的索引来进行替换操作。
在下面的例子中，我们先通过zeros_like创建和Y形状相同且元素为0的tensor，记为Z。
接下来，我们把X + Y的结果通过[:]写进Z对应的内存中。
"""
Z = tf.Variable(tf.zeros_like(Y))
before_id = id(Z)
Z[:].assign(X + Y)
now_id = id(Z)
print(before_id, now_id, before_id == now_id)
# 2245196592520 2245196592520 True

"""
实际上，上例中我们还是为X + Y开了临时内存来存储计算结果，再复制到Z对应的内存。
如果想避免这个临时内存开销，我们可以使用assign_{运算符全名}函数。
"""
before_id = id(X)
X.assign_add(Y)
now_id = id(X)
print(before_id == now_id)  # True

"""
如果X的值在之后的程序中不会复用，我们也可以用 X[:] = X + Y 或者 X += Y 来减少运算的内存开销。
这个程序好像不太对！！！
"""
before_id = id(X)
X.assign_add(Y)
now_id = id(X)
print(before_id == now_id)  # True

2.2.6 tensor和numpy互换


"""
我们可以通过array函数和asnumpy函数令数据在NDArray和NumPy格式之间相互变换。
下面将NumPy实例变换成tensor实例。
"""
import numpy as np

P = np.ones((2, 3))
D = tf.constant(P)
print(D)
# tf.Tensor(
# [[1. 1. 1.]
#  [1. 1. 1.]], shape=(2, 3), dtype=float64)

"""再将ndarray实例变换成NumPy实例。"""
print(type(np.array(D)), '\n', np.array(D))
# <class 'numpy.ndarray'>
# [[1. 1. 1.]
#  [1. 1. 1.]]

2.3 自动求梯度

在深度学习中，我们经常需要对函数求梯度（gradient）。本节将介绍如何使用tf2提供的GradientTape来自动求梯度。
GradientTape 可以理解为‘梯度流 记录磁带’：
在记录阶段：记录被GradientTape包裹的运算过程中，依赖于 source node（被 watch ‘监视’的变量）的关系图。
在求导阶段：通过搜索 source node 到 target node 的路径，进而计算出偏微分。

source node 在记录运算过程之前进行指定：
自动“监控”所有可训练变量：
GradientTape 默认（watch_accessed_variables=True）将所有可训练变量（created by tf.Variable, where trainable=True）
视为需要“监控”的 source node 。

对于不可训练的变量（比如tf.constant）可以使用tape.watch()对其进行“监控”。
此外，还可以设定watch_accessed_variables=False，然后使用tf.watch()精确控制需要“监控”哪些变量。

2.3.1 简单示例

import tensorflow as tf

"""先看一个简单的示例"""
x = tf.reshape(tf.Variable(range(4), dtype=tf.float32), (4, -1))
print(x)
# tf.Tensor(
# [[0.]
#  [1.]
#  [2.]
#  [3.]], shape=(4, 1), dtype=float32)

print(tf.transpose(x))
# tf.Tensor([[0. 1. 2. 3.]], shape=(1, 4), dtype=float32)

print(tf.matmul(tf.transpose(x), x))
# tf.Tensor([[14.]], shape=(1, 1), dtype=float32)

with tf.GradientTape() as t:
    t.watch(x)  # 对于Variable类型的变量，一般不用加此监控
    y = 2 * tf.matmul(tf.transpose(x), x)

# y = [2x.T][x] 关于 x 的梯度应为 4x
dy_dx = t.gradient(y, x)
print(dy_dx)
# tf.Tensor(
# [[ 0.]
#  [ 4.]
#  [ 8.]
#  [12.]], shape=(4, 1), dtype=float32)

2.3.2 训练模式和预测模式

with tf.GradientTape(persistent=True) as g:
    g.watch(x)
    y = x * x
    z = y * y
    dz_dx = g.gradient(z, x)
    dy_dx = g.gradient(y, z)
print(dz_dx)
# tf.Tensor(
# [[ 0.]
#  [ 4.]
#  [ 8.]
#  [12.]], shape=(4, 1), dtype=float32)

print(dy_dx)
# tf.Tensor(
# [[  0.]
#  [  4.]
#  [ 32.]
#  [108.]], shape=(4, 1), dtype=float32)

2.3.3 对Python控制流求梯度

即使函数的计算图包含了Python的控制流（如条件控制和循环控制），我们也有可能对变量求梯度。
考虑下面的程序，其中包含了Python的条件控制和循环控制，
需要强调的是，这里循环（while循环）迭代的次数和条件判断（if语句）的执行都取决于输入的a值。

def f(a):
    b = a * 2
    while tf.norm(b) < 1000:
        b = b * 2
    if tf.reduce_sum(b) > 0:
        c = b
    else:
        c = 100 * b
    return c


# 我们来分析一下上面定义的f函数。事实上，给定任意输入a，其输出必然是 f(a) = x * a的形式，
# 其中标量系数x的值取决于输入a。由于c = f(a)有关a的梯度为x，且值为c / a，
# 我们可以像下面这样验证对本例中控制流求梯度的结果的正确性。
a = tf.random.normal((1, 1), dtype=tf.float32)
with tf.GradientTape() as t:
    t.watch(a)
    c = f(a)
print(t.gradient(c, a))
# tf.Tensor([[204800.]], shape=(1, 1), dtype=float32)
print(c / a)
# tf.Tensor([[204800.]], shape=(1, 1), dtype=float32)

2.4 查阅文档

受篇幅所限，本书无法对所有用到的tensorflow2.0函数和类一一详细介绍。
读者可以查阅相关文档来做更深入的了解。

2.4.1 search for functions and classes

当我们想知道一个模块里面提供了哪些可以调用的函数和类的时候，可以使用dir函数。
下面我们打印dtypes和random模块中所有的成员或属性。

import tensorflow as tf
print(dir(tf.dtypes))
# ['DType',
# 'QUANTIZED_DTYPES',
# '__builtins__',
# '__cached__',
# '__doc__',
# '__file__',
# '__loader__',
# '__name__',
# '__package__',
# '__path__',
# '__spec__',
# '_sys',
# 'as_dtype',
# 'bfloat16',
# 'bool',
# 'cast',
# 'complex',
# 'complex128',
# 'complex64',
# 'double',
# 'float16',
# 'float32',
# 'float64',
# 'half',
# 'int16',
# 'int32',
# 'int64',
# 'int8',
# 'qint16',
# 'qint32',
# 'qint8',
# 'quint16',
# 'quint8',
# 'resource',
# 'saturate_cast',
# 'string',
# 'uint16',
# 'uint32',
# 'uint64',
# 'uint8',
# 'variant']

通常我们可以忽略掉由__开头和结尾的函数（Python的特别对象）或者由_开头的函数（一般为内部函数）。

其余成员通过名字我们大致猜测出这个模块提供了各种随机数的生成方法，包括从均匀分布采样（uniform）、从正态分布采样（normal）、从泊松分布采样（poisson）等。

print(dir(tf.random))
# ['Algorithm',
# 'Generator',
# '__builtins__',
# '__cached__',
# '__doc__',
# '__file__',
# '__loader__',
# '__name__',
# '__package__',
# '__path__',
# '__spec__',
# '_sys',
# 'all_candidate_sampler',
# 'categorical',
# 'create_rng_state',
# 'experimental',
# 'fixed_unigram_candidate_sampler',
# 'gamma',
# 'get_global_generator',
# 'learned_unigram_candidate_sampler',
# 'log_uniform_candidate_sampler',
# 'normal',
# 'poisson',
# 'set_global_generator',
# 'set_seed',
# 'shuffle',
# 'stateless_binomial',
# 'stateless_categorical',
# 'stateless_gamma',
# 'stateless_normal',
# 'stateless_parameterized_truncated_normal',
# 'stateless_poisson',
# 'stateless_truncated_normal',
# 'stateless_uniform',
# 'truncated_normal',
# 'uniform',
# 'uniform_candidate_sampler']

2.4.2.4.2 use of functions

想了解某个函数或者类的具体用法时，可以使用help函数。让我们以ones函数为例，查阅它的用法。
更详细的信息，可以通过Tensorflow的API文档版本选择页，选择与自己环境中的 tensorflow 版本一致的 API 版本进行查询。

print(help(tf.ones))
# Help on function ones in module tensorflow.python.ops.array_ops:
#
# ones(shape, dtype=tf.float32, name=None)
#     Creates a tensor with all elements set to one (1).
#
#     See also `tf.ones_like`, `tf.zeros`, `tf.fill`, `tf.eye`.
#
#     This operation returns a tensor of type `dtype` with shape `shape` and
#     all elements set to one.
#
#     >>> tf.ones([3, 4], tf.int32)
#     <tf.Tensor: shape=(3, 4), dtype=int32, numpy=
#     array([[1, 1, 1, 1],
#            [1, 1, 1, 1],
#            [1, 1, 1, 1]], dtype=int32)>
#
#     Args:
#       shape: A `list` of integers, a `tuple` of integers, or
#         a 1-D `Tensor` of type `int32`.
#       dtype: Optional DType of an element in the resulting `Tensor`. Default is
#         `tf.float32`.
#       name: Optional string. A name for the operation.
#
#     Returns:
#       A `Tensor` with all elements set to one (1).
#
# None

从文档信息我们了解到，ones函数会创建和输入tensor形状相同且元素为1的新tensor。我们可以验证一下：

print(tf.ones([2, 3], tf.int32))
# tf.Tensor(
# [[1 1 1]
#  [1 1 1]], shape=(2, 3), dtype=int32)

完整代码


import tensorflow as tf

print(tf.__version__)
# 2.4.0
"""
2.2 数据操作
在深度学习中，我们通常会频繁地对数据进行操作。作为动手学深度学习的基础，本节将介绍如何对内存中的数据进行操作。
在TensorFlow中，tensor是一个类，也是存储和变换数据的主要工具。如果你之前用过NumPy，你会发现tensor和NumPy的多维数组非常类似。然而，tensor提供GPU计算和自动求梯度等更多功能，这些使tensor更加适合深度学习。
"""

################################
#
# 2.2.1 创建tensor
#
################################

""" 先介绍tensor的最基本功能，我们用range函数创建一个行向量。"""
x = tf.constant(range(12))

print(x.shape)
# (12,)

# 一个tensor实例，其中包含了从0开始的12个连续整数。
print(x)
# tf.Tensor([ 0  1  2  3  4  5  6  7  8  9 10 11], shape=(12,), dtype=int32)

# 通过len得到tensor实例中元素（element）的总数
print(len(x))
# 12

"""下面使用reshape函数把行向量x的形状改为(3, 4)，也就是一个3行4列的矩阵，并记作X。除了形状改变之外，X中的元素保持不变。"""
# 也可写成x.reshape((-1, 4))或x.reshape((3, -1))。由于x的元素个数是已知的，这里的-1是能够通过元素个数和其他维度的大小推断出来的。
X = tf.reshape(x, (3, 4))
print(X)
# tf.Tensor(
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]], shape=(3, 4), dtype=int32)

"""接下来，我们创建一个各元素为0，形状为(2, 3, 4)的张量。实际上，之前创建的向量和矩阵都是特殊的张量。"""
X0 = tf.zeros((2, 3, 4))
print(X0)
# tf.Tensor(
# [[[0. 0. 0. 0.]
#   [0. 0. 0. 0.]
#   [0. 0. 0. 0.]]
#
#  [[0. 0. 0. 0.]
#   [0. 0. 0. 0.]
#   [0. 0. 0. 0.]]], shape=(2, 3, 4), dtype=float32)

"""类似地，我们可以创建各元素为1的张量。"""
X1 = tf.ones((3, 4))
print(X1)
# tf.Tensor(
# [[1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]], shape=(3, 4), dtype=float32)

"""也可以通过Python的列表（list）指定需要创建的tensor中每个元素的值。"""
Y = tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(Y.shape)  # (3, 4)
print(Y)
# tf.Tensor(
# [[2 1 4 3]
#  [1 2 3 4]
#  [4 3 2 1]], shape=(3, 4), dtype=int32)

"""随机生成tensor中每个元素的值。下面我们创建一个形状为(3, 4)的tensor。它的每个元素都随机采样于均值为0、标准差为1的正态分布。"""
# X2 = tf.random.normal(shape=[3, 4], mean=0, stddev=1)
X2 = tf.random.normal(shape=(3, 4), mean=0, stddev=1)  # 这两种都可以·    1m
print(X2)
# tf.Tensor(
# [[-0.6286057  -1.5282005   2.149251   -0.5682216 ]
#  [ 0.03127453  0.5830824   0.6466156  -0.5903981 ]
#  [ 0.05115638 -1.6249142  -1.1675135  -0.78749204]], shape=(3, 4), dtype=float32)
print('###' * 30)

################################
#
# 2.2.2 运算
#
################################

print(X)
# tf.Tensor(
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]], shape=(3, 4), dtype=int32)
print(Y)
# tf.Tensor(
# [[2 1 4 3]
#  [1 2 3 4]
#  [4 3 2 1]], shape=(3, 4), dtype=int32)
print(X + Y)  # 按元素加法：对应位置相加
# tf.Tensor(
# [[ 2  2  6  6]
#  [ 5  7  9 11]
#  [12 12 12 12]], shape=(3, 4), dtype=int32)

print(X * Y)  # 按元素乘法：对应位置相乘
# tf.Tensor(
# [[ 0  1  8  9]
#  [ 4 10 18 28]
#  [32 27 20 11]], shape=(3, 4), dtype=int32)

print(X / Y)  # 按元素除法：对应位置相除
# tf.Tensor(
# [[ 0.    1.    0.5   1.  ]
#  [ 4.    2.5   2.    1.75]
#  [ 2.    3.    5.   11.  ]], shape=(3, 4), dtype=float64)

Y = tf.cast(Y, tf.float32)  # 类型转换：dtype=int32 --> dtype=float32
print(Y)
# tf.Tensor(
# [[2. 1. 4. 3.]
#  [1. 2. 3. 4.]
#  [4. 3. 2. 1.]], shape=(3, 4), dtype=float32)
print(tf.exp(Y))  # 按元素做指数运算：对应位置做指数运算
# tf.Tensor(
# [[ 7.389056   2.7182817 54.598152  20.085537 ]
#  [ 2.7182817  7.389056  20.085537  54.598152 ]
#  [54.59815   20.085537   7.389056   2.7182817]], shape=(3, 4), dtype=float32)

"""
除了按元素计算外，我们还可以使用matmul(matrix multiply)函数做矩阵乘法。下面将X与Y的转置做矩阵乘法。
由于X是3行4列的矩阵，Y转置为4行3列的矩阵，因此两个矩阵相乘得到3行3列的矩阵。
"""
Y = tf.cast(Y, tf.int32)
print(tf.matmul(X, tf.transpose(Y)))
# tf.Tensor(
# [[ 18  20  10]
#  [ 58  60  50]
#  [ 98 100  90]], shape=(3, 3), dtype=int32)

"""
也可以将多个tensor连结（concatenate）。
下面分别在行上（维度0，即形状中的最左边元素）和列上（维度1，即形状中左起第二个元素）连结两个矩阵。
可以看到，输出的第一个tensor在维度0的长度（ 6 ）为两个输入矩阵在维度0的长度之和（ 3+3 ），
       而输出的第二个tensor在维度1的长度（ 8 ）为两个输入矩阵在维度1的长度之和（ 4+4 ）。
"""
print(tf.concat([X, Y], axis=0))
# tf.Tensor(
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [ 2  1  4  3]
#  [ 1  2  3  4]
#  [ 4  3  2  1]], shape=(6, 4), dtype=int32)

print(tf.concat([X, Y], axis=1))
# tf.Tensor(
# [[ 0  1  2  3  2  1  4  3]
#  [ 4  5  6  7  1  2  3  4]
#  [ 8  9 10 11  4  3  2  1]], shape=(3, 8), dtype=int32)

"""
使用条件判断式可以得到元素为0或1的新的tensor。
    以X == Y为例，如果X和Y在相同位置的条件判断为真（值相等），那么新的tensor在相同位置的值为1；反之为0。
"""
print(tf.equal(X, Y))
# tf.Tensor(
# [[False  True False  True]
#  [False False False False]
#  [False False False False]], shape=(3, 4), dtype=bool)

"""对tensor中的所有元素求和得到只有一个元素的tensor。"""
print(tf.reduce_sum(X))
# tf.Tensor(66, shape=(), dtype=int32)

X = tf.cast(X, tf.float32)
print(tf.norm(X))  # 各元素平方和的开方，即L2范数
# tf.Tensor(22.494444, shape=(), dtype=float32)


################################
#
# 2.2.3 广播机制
#
################################

# 前面我们看到如何对两个形状相同的tensor做按元素运算。
# 当对两个形状不同的tensor按元素运算时，可能会触发广播（broadcasting）机制。
# 广播（broadcasting）机制：先适当复制元素使这两个tensor形状相同后再按元素运算。

A = tf.reshape(tf.constant(range(3)), (3, 1))
B = tf.reshape(tf.constant(range(2)), (1, 2))
print(A)
# tf.Tensor(
# [[0]
#  [1]
#  [2]], shape=(3, 1), dtype=int32)
print(B)
# tf.Tensor([[0 1]], shape=(1, 2), dtype=int32)

"""
A和B分别是3行1列和1行2列的矩阵，
如果要计算A + B，那么A中第一列的3个元素被广播（复制）到了第二列，而B中第一行的2个元素被广播（复制）到了第二行和第三行。
如此，就可以对2个3行2列的矩阵按元素相加。
"""
print(A + B)
# tf.Tensor(
# [[0 1]
#  [1 2]
#  [2 3]], shape=(3, 2), dtype=int32)

################################
#
# 2.2.4 索引
#
################################
"""截取了矩阵X中行索引为1和2的两行"""
# 在tensor中，索引（index）代表了元素的位置。tensor的索引从0开始逐一递增。
# 例如，一个3行2列的矩阵的行索引分别为0、1和2，列索引分别为0和1。
# 在下面的例子中，我们指定了tensor的行索引截取范围[1:3]。依据左闭右开指定范围的惯例，它截取了矩阵X中行索引为1和2的两行。

print(X[1:3])
# [[ 4.  5.  6.  7.]
#  [ 8.  9. 10. 11.]], shape=(2, 4), dtype=float32)

"""我们可以指定tensor中需要访问的单个元素的位置，如矩阵中行和列的索引，并为该元素重新赋值。"""
X = tf.Variable(X)  # Variable是可更改的，而Tensor是不可更改的https://blog.csdn.net/u013841196/article/details/82960765
print(X[1, 2].assign(911))
# <tf.Variable 'UnreadVariable' shape=(3, 4) dtype=float32, numpy=
# array([[  0.,   1.,   2.,   3.],
#        [  4.,   5., 911.,   7.],
#        [  8.,   9.,  10.,  11.]], dtype=float32)>

"""当然，我们也可以截取一部分元素，并为它们重新赋值。在下面的例子中，我们为行索引为1的每一列元素重新赋值。"""
print(X[1:2, :].assign(tf.ones(X[1:2, :].shape, dtype=tf.float32) * 120))
# <tf.Variable 'UnreadVariable' shape=(3, 4) dtype=float32, numpy=
# array([[  0.,   1.,   2.,   3.],
#        [120., 120., 120., 120.],
#        [  8.,   9.,  10.,  11.]], dtype=float32)>


################################
#
# 2.2.5 运算的内存开销
#
################################
"""查看操作新开的内存"""
X = tf.Variable(X)
Y = tf.cast(Y, dtype=tf.float32)
before_id = id(Y)
Y = Y + X
now_id = id(Y)
print(before_id, now_id, before_id == now_id)
# 2145964333192 2145964333368 False

"""
如果想指定结果到特定内存，我们可以使用前面介绍的索引来进行替换操作。
在下面的例子中，我们先通过zeros_like创建和Y形状相同且元素为0的tensor，记为Z。
接下来，我们把X + Y的结果通过[:]写进Z对应的内存中。
"""
Z = tf.Variable(tf.zeros_like(Y))
before_id = id(Z)
Z[:].assign(X + Y)
now_id = id(Z)
print(before_id, now_id, before_id == now_id)
# 2245196592520 2245196592520 True

"""
实际上，上例中我们还是为X + Y开了临时内存来存储计算结果，再复制到Z对应的内存。
如果想避免这个临时内存开销，我们可以使用assign_{运算符全名}函数。
"""
before_id = id(X)
X.assign_add(Y)
now_id = id(X)
print(before_id == now_id)  # True

"""
如果X的值在之后的程序中不会复用，我们也可以用 X[:] = X + Y 或者 X += Y 来减少运算的内存开销。
这个程序好像不太对！！！
"""
before_id = id(X)
X.assign_add(Y)
now_id = id(X)
print(before_id == now_id)  # True

################################
#
# 2.2.6 tensor和numpy互换
#
################################
"""
我们可以通过array函数和asnumpy函数令数据在NDArray和NumPy格式之间相互变换。
下面将NumPy实例变换成tensor实例。
"""
import numpy as np

P = np.ones((2, 3))
D = tf.constant(P)
print(D)
# tf.Tensor(
# [[1. 1. 1.]
#  [1. 1. 1.]], shape=(2, 3), dtype=float64)

"""再将ndarray实例变换成NumPy实例。"""
print(type(np.array(D)), '\n', np.array(D))
# <class 'numpy.ndarray'>
# [[1. 1. 1.]
#  [1. 1. 1.]]



"""
2.3 自动求梯度

在深度学习中，我们经常需要对函数求梯度（gradient）。本节将介绍如何使用tf2提供的GradientTape来自动求梯度。
GradientTape 可以理解为‘梯度流 记录磁带’：
    在记录阶段：记录被GradientTape包裹的运算过程中，依赖于 source node（被 watch ‘监视’的变量）的关系图。
    在求导阶段：通过搜索 source node 到 target node 的路径，进而计算出偏微分。

source node 在记录运算过程之前进行指定：
自动“监控”所有可训练变量：
    GradientTape 默认（watch_accessed_variables=True）将所有可训练变量（created by tf.Variable, where trainable=True）
    视为需要“监控”的 source node 。
    
    对于不可训练的变量（比如tf.constant）可以使用tape.watch()对其进行“监控”。
    此外，还可以设定watch_accessed_variables=False，然后使用tf.watch()精确控制需要“监控”哪些变量。
"""


import tensorflow as tf
###########################################
#
# 2.3.1 简单示例
#
###########################################
"""先看一个简单的示例"""
x = tf.reshape(tf.Variable(range(4), dtype=tf.float32), (4, -1))
print(x)
# tf.Tensor(
# [[0.]
#  [1.]
#  [2.]
#  [3.]], shape=(4, 1), dtype=float32)

print(tf.transpose(x))
# tf.Tensor([[0. 1. 2. 3.]], shape=(1, 4), dtype=float32)

print(tf.matmul(tf.transpose(x), x))
# tf.Tensor([[14.]], shape=(1, 1), dtype=float32)

with tf.GradientTape() as t:
    t.watch(x)  # 对于Variable类型的变量，一般不用加此监控
    y = 2 * tf.matmul(tf.transpose(x), x)

# y = [2x.T][x] 关于 x 的梯度应为 4x
dy_dx = t.gradient(y, x)
print(dy_dx)
# tf.Tensor(
# [[ 0.]
#  [ 4.]
#  [ 8.]
#  [12.]], shape=(4, 1), dtype=float32)



###########################################
#
# 2.3.2 训练模式和预测模式
#
###########################################
with tf.GradientTape(persistent=True) as g:
    g.watch(x)
    y = x * x
    z = y * y
    dz_dx = g.gradient(z, x)
    dy_dx = g.gradient(y, z)
print(dz_dx)
# tf.Tensor(
# [[ 0.]
#  [ 4.]
#  [ 8.]
#  [12.]], shape=(4, 1), dtype=float32)

print(dy_dx)
# tf.Tensor(
# [[  0.]
#  [  4.]
#  [ 32.]
#  [108.]], shape=(4, 1), dtype=float32)



###########################################
#
# 2.3.3 对Python控制流求梯度
#
###########################################
"""
即使函数的计算图包含了Python的控制流（如条件控制和循环控制），我们也有可能对变量求梯度。
考虑下面的程序，其中包含了Python的条件控制和循环控制，
需要强调的是，这里循环（while循环）迭代的次数和条件判断（if语句）的执行都取决于输入的a值。
"""
def f(a):
    b = a * 2
    while tf.norm(b) < 1000:
        b = b * 2
    if tf.reduce_sum(b) > 0:
        c = b
    else:
        c = 100 * b
    return c
# 我们来分析一下上面定义的f函数。事实上，给定任意输入a，其输出必然是 f(a) = x * a的形式，
# 其中标量系数x的值取决于输入a。由于c = f(a)有关a的梯度为x，且值为c / a，
# 我们可以像下面这样验证对本例中控制流求梯度的结果的正确性。
a = tf.random.normal((1,1), dtype=tf.float32)
with tf.GradientTape() as t:
    t.watch(a)
    c = f(a)
print(t.gradient(c, a))
# tf.Tensor([[204800.]], shape=(1, 1), dtype=float32)
print(c / a)
# tf.Tensor([[204800.]], shape=(1, 1), dtype=float32)



import tensorflow as tf

"""
2.4 查阅文档
受篇幅所限，本书无法对所有用到的tensorflow2.0函数和类一一详细介绍。
读者可以查阅相关文档来做更深入的了解。
"""



#############################################
#
# 2.4.1 search for functions and classes
#
#############################################
"""
当我们想知道一个模块里面提供了哪些可以调用的函数和类的时候，可以使用dir函数。
下面我们打印dtypes和random模块中所有的成员或属性。
"""
print(dir(tf.dtypes))
# ['DType',
# 'QUANTIZED_DTYPES',
# '__builtins__',
# '__cached__',
# '__doc__',
# '__file__',
# '__loader__',
# '__name__',
# '__package__',
# '__path__',
# '__spec__',
# '_sys',
# 'as_dtype',
# 'bfloat16',
# 'bool',
# 'cast',
# 'complex',
# 'complex128',
# 'complex64',
# 'double',
# 'float16',
# 'float32',
# 'float64',
# 'half',
# 'int16',
# 'int32',
# 'int64',
# 'int8',
# 'qint16',
# 'qint32',
# 'qint8',
# 'quint16',
# 'quint8',
# 'resource',
# 'saturate_cast',
# 'string',
# 'uint16',
# 'uint32',
# 'uint64',
# 'uint8',
# 'variant']
"""
通常我们可以忽略掉由__开头和结尾的函数（Python的特别对象）或者由_开头的函数（一般为内部函数）。
其余成员通过名字我们大致猜测出这个模块提供了各种随机数的生成方法，
包括从均匀分布采样（uniform）、从正态分布采样（normal）、从泊松分布采样（poisson）等。
"""
print(dir(tf.random))
# ['Algorithm',
# 'Generator',
# '__builtins__',
# '__cached__',
# '__doc__',
# '__file__',
# '__loader__',
# '__name__',
# '__package__',
# '__path__',
# '__spec__',
# '_sys',
# 'all_candidate_sampler',
# 'categorical',
# 'create_rng_state',
# 'experimental',
# 'fixed_unigram_candidate_sampler',
# 'gamma',
# 'get_global_generator',
# 'learned_unigram_candidate_sampler',
# 'log_uniform_candidate_sampler',
# 'normal',
# 'poisson',
# 'set_global_generator',
# 'set_seed',
# 'shuffle',
# 'stateless_binomial',
# 'stateless_categorical',
# 'stateless_gamma',
# 'stateless_normal',
# 'stateless_parameterized_truncated_normal',
# 'stateless_poisson',
# 'stateless_truncated_normal',
# 'stateless_uniform',
# 'truncated_normal',
# 'uniform',
# 'uniform_candidate_sampler']




#############################################
#
# 2.4.2.4.2 use of functions
#
#############################################
"""
想了解某个函数或者类的具体用法时，可以使用help函数。让我们以ones函数为例，查阅它的用法。
更详细的信息，可以通过Tensorflow的API文档版本选择页，选择与自己环境中的 tensorflow 版本一致的 API 版本进行查询。
"""
print(help(tf.ones))
# Help on function ones in module tensorflow.python.ops.array_ops:
#
# ones(shape, dtype=tf.float32, name=None)
#     Creates a tensor with all elements set to one (1).
#
#     See also `tf.ones_like`, `tf.zeros`, `tf.fill`, `tf.eye`.
#
#     This operation returns a tensor of type `dtype` with shape `shape` and
#     all elements set to one.
#
#     >>> tf.ones([3, 4], tf.int32)
#     <tf.Tensor: shape=(3, 4), dtype=int32, numpy=
#     array([[1, 1, 1, 1],
#            [1, 1, 1, 1],
#            [1, 1, 1, 1]], dtype=int32)>
#
#     Args:
#       shape: A `list` of integers, a `tuple` of integers, or
#         a 1-D `Tensor` of type `int32`.
#       dtype: Optional DType of an element in the resulting `Tensor`. Default is
#         `tf.float32`.
#       name: Optional string. A name for the operation.
#
#     Returns:
#       A `Tensor` with all elements set to one (1).
#
# None

"""从文档信息我们了解到，ones函数会创建和输入tensor形状相同且元素为1的新tensor。我们可以验证一下："""
print(tf.ones([2, 3], tf.int32))
# tf.Tensor(
# [[1 1 1]
#  [1 1 1]], shape=(2, 3), dtype=int32)
TPAMI 2024 | 无监督图像重建的孪生合作学习方法
小白学视觉
08-12 461
题目：Siamese Cooperative Learning for Unsupervised Image Reconstruction From Incomplete Measurements 无监督图像重建的孪生合作学习方法 作者：Yuhui Quan; Xinran Qin; Tongyao Pang; Hui Ji 摘要 从不完整测量中重建图像是成像中的基本任务。尽管近年来有监督的深度学习已成为图像重建的强大工具，但其应用受限于需要大量潜在图像进行模型训练。为扩展深度学习在获取潜在图像具有挑战性
动手学深度学习 + TF2.0开源项目，不容错过
AI科技大本营
12-06 626
作者 | 深度传送门来源 | 深度传送门（ID:deep_deliver)关于项目本项目将《动手学深度学习》(Dive into Deep Learning)原书中的MXNet实现改为T...
《动手学深度学习》TF2.0 实现
热门推荐
龙哥盟
12-11 3万+
本项目将《动手学深度学习》 原书中MXNet代码实现改为TensorFlow2.0实现。经过我的导师咨询李沐老师，这个项目的实施已得到李沐老师的同意。原书作者：阿斯顿·张、李沐、扎卡里 C. 立顿、亚历山大 J. 斯莫拉以及其他社区贡献者，GitHub地址：https://github.com/d2l-ai/d2l-zh 此书的中、英版本存在一些不同，本项目主要针对此书的中文版进行Tensor...
TensorFlow随机值：tf.random_normal函数
weixin_30737433的博客
02-20 147
tf.random_normal 函数 random_normal( shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None ) 定义在：tensorflow/python/ops/random_ops.py. 请参阅指南：生成常量,序列和随机值&gt...
【tf2函数】tf.random_normal()
A_Coding_Man
08-23 550
tf.random_normal() tf.random_normal()函数用于从“服从指定正态分布的序列”中随机取出指定个数的值。 tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) - shape: 输出张量的形状，必选 - mean: 正态分布的均值，默认为0 - stddev: 正态分布的标准差，默认为1.0 - dtype: 输出的类型，默认为tf.float32 - seed
关于学习tf.random.normal()和tf.random.uniform()的一点小总结
Keep_Trying_Go的博客
03-31 789
tf.random.normal(shape,mean=0.0,stddev=1.0)-正态分布 1.shape-可以创建形状为shape的数组 2.mean-均值 3.stddev-标准差，正态分布N（mean，stddev^2） 例如：import tensorflow as tf import numpy as np x=tf.random.normal([2,3],stddev=0.1) print(x)
深度学习入门—tensorflow2—2.1预备知识
NeverMind的博客
10-12 225
预备知识tf.wherenp.random.RandomState.randnp.vstacknp.mgrid[]      .ravel()      np.c_[]np.mgrid 用法 tf.where tf.where(条件语句，真返回A，假返回B) import tensorflow as tf a = tf.constant([1, 2, 3, 1, 1]) b = tf.constant([0
window深度学习预备——gpu环境配置
qq_45988809的博客
07-21 909
cuda环境配置，tf，torch，gpu配置 最近有很多同学准备入门深度学习，为了做软件课设。我在这里分享一些我的经验。 首先确定你的电脑有NVIDIA显卡，目前只有n卡能提供gpu算力。 查看你的电脑支持的最高cuda版本 打卡英伟达控制面板 或者直接在搜索栏中搜索 然后就会看到以下的画面 GeForce GTX 1050 是我的n卡型号，注意记下上面的版本数值，这个数值是Driver Version（驱动程序版本）。我们要根据这个驱动程序版本去选择对应的cuda版本。 这是我在官网截的图，驱动
机器学习——python机器学习第2版笔记
weixin_45562632的博客
08-17 2333
python机器学习第二版笔记1 赋予计算机从数据中学习的能力1.1 构建把数据转换成知识的智能1.2 三种不同类型的机器学习1.3 基本术语与符号1.4 构建机器学习系统的路线图1.5 用python进行机学习2 训练简单的机器学习分类算法2.1 人工神经元——机器学习早期历史一瞥2.2 在python中实现感知器学习2.3 自适应神经元和学习收敛3 scikit-learn机器学习分类器一览3.1 选择分类算法3.2 了解scikit-learn软件库的第一步——训练感知器3.3 基于逻辑回归的分类概率
TensorFlow神经网络学习笔记
qq_35578807的博客
09-27 2635
张量（tensor） 就是多维数组 阶代表张量的维数 维数 阶 名字 0-D 0 标量scalar 1-D 1 向量vector 2-D 2 矩阵 matrix n-D n 张量 tensor 张量可以表示0阶到n阶的数组（列表） 数据
tf.random_normal()函数
weixin_30278237的博客
01-11 3429
tf.random_normal()函数用于从服从指定正太分布的数值中取出指定个数的值。 tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) shape: 输出张量的形状，必选 mean: 正态分布的均值，默认为0 stdd...
Tensorflow2.x 线性回归的实现
weixin_50314406的博客
07-17 557
目录 1.自己学习笔记： 2. tf.random_normal()函数： 3. 遇到的问题： 解决：tensorflow have no attribute enable_eager_execution()__yuki_-CSDN博客 (11条消息) torch.from_numpy()_NDHuaErFeiFei的博客-CSDN博客 TensorFlow随机值：tf.random_normal函数_w3cschool 4. 整个代码： 1.自己学习笔记： 线性回归的实现一般有以下.
tensorflow tf.Variable 的用法
weixin_44493841的博客
11-04 1039
import tensorflow as tf #导入模块 import numpy as np tf.Variable(3) # 数字输入 <tf.Variable ‘Variable:0’ shape=() dtype=int32, numpy=3> tf.Variable(np.array(3.)) # 浮点数输入 <tf.Variable ‘Variable:0’ shape=() dtype=float64, numpy=3.0> tf.Variable([1
TensorFlow 从入门到精通（0）—— tensorflow编程基础
厚积而薄发
09-17 497
import tensorflow as tf 一、初体验 node1 = tf.constant([[1,2,3],[4,5,6]]) node2 = tf.constant([[1,2,3],[4,5,6]]) node3 = tf.add(node1,node2) node3 <tf.Tensor: shape=(2, 3), dtype=int32, numpy= array([[ 2, 4, 6], [ 8, 10, 12]], dtype=int32)> #
TensorFlow常用函数
qq_42250782的博客
02-28 890
TensorFlow常用函数 目录TensorFlow常用函数1 tensorflow.where()1.1 where(t) 返回Tensor==True的索引坐标1.2 where(t, a, b) 合并两个Tensor数据, t, a, b 必须是同shape 或者 可进行广播broadcastable2 tensorflow.reduce_sum()3 tensorflow.random.normal()4 tf.random.uniform()5 tensor.reshape()6 tensor
TF2.0深度学习实战（一）：分类问题之手写数字识别
不积跬步，无以至千里！
03-06 1万+
你与AI只差这一步～
tensorflow2.0---张量的创建以及tf的简单操作
qq_46244851的博客
09-27 1270
目录1.tf2的'hello world'2.创建张量3.创建随机数张量--正态分布（tf.random模块） 1.tf2的’hello world’ 在电脑上安装tensorflow2.0即可，安装教程网上很多，在此不再赘述。安装之后： import tensorflow as tf #引入tensorflow print(tf.__version__) #查看tensorflow版本号 print(tf.test.is_gpu_available())#如果是安装的gpu版本，用来查看g
基于tf2的dl编程学习(一)
shiningsword的博客
11-11 387
基于tf2的dl编程学习(一) 主要介绍tensorflow的基础部分的核心概念与机制，总结tensorflow作为通用计算框架的一些知识点。主要分为张量，计算图和自动微分机制三个部分。Tensorflow是一个通过计算图的形式来描述计算的编程系统，节点为定义的数学计算，而连接节点的边即为张量。张量在计算图中流动，进出节点完成计算，最终流到终点得到结果。 张量 张量(Tensor)是tensorflow中基础的数据结构，就像Ndarray之于Numpy一样。二者的行为特性也十分相似，都是描述多维数组，操作，
TensorFlow2.0教程-Variables
知行_那片天
03-16 8953
TensorFlow教程-Variables 创建一个变量 import tensorflow as tf my_var = tf.Variable(tf.ones([2,3])) print(my_var) try: with tf.device(&amp;quot;/device:GPU:0&amp;quot;): v = tf.Variable(tf.zeros([10, 10])) p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
>