深度学习TensorFlow2基础知识学习前半部分

本文介绍: tf中变量定义为Var i a ble，常量Te n sor（这里懂了吧，pytorch 里面都是Te n sor，但是tf 里面的Te n sor 代表向量其实也是可变的），要注意的是Va ri a ble 数组和变量数值之间的加减乘除可以进行广播机制的运算，而且常量和变量之间也是可以相加的。import os# 定义变量print(a)print(b)pr int(c)pr int(d)# pr int(a+b) # error:类型不匹配 pr int(b+c) # 注意这里是Ten sor 类型。

测试TensorFlow是否支持GPU：

框架本身只是用来编写的工具，每个框架包括Py torch，tensorflow、mx net、paddle、m and sp o re等等框架编程语言上其实差别是大同小异的，不同的点是他们在编译方式、运行方式或者计算速度上，我也浅浅的学习一下这个框架以便于看github上的代码可以轻松些。

我的环境：

google co lab的T4 GPU

首先是

测试Ten sorFlow 是否 支持GPU：

打开 tf的config包，里面有个 list _py s ical_devices(“GPU”)

import os
import tensorflow as tf

os.environ['TF_CPP_Min_LOG_LEVEL']='3'
os.system("clear")
print("GPU列表：",tf.config.list_logical_devices("GPU"))

运行结果：

GPU列表： [Lo g icalDevi ce(name=’/device:GPU:0′, device_type=’GPU’)]

检测运行时间：

def run():
  n=1000
  #CPU计算矩阵
  with tf.device('/cpu:0'):
    cpu_a = tf.random.normal([n,n])
    cpu_b = tf.random.normal([n,n])
    print(cpu_a.device,cpu_b.device)
  #GPU计算矩阵
  with tf.device('/gpu:0'):
    gpu_a = tf.random.normal([n,n])
    gpu_b = tf.random.normal([n,n])
    print(gpu_a.device,gpu_b.device)
  def cpu_run():
    with tf.device('/cpu:0'):
      c = tf.matmul(cpu_a,cpu_b)
    return c
  def gpu_run():
    with tf.device('/cpu:0'):
      c = tf.matmul(gpu_a,gpu_b)
    return c
  number=1000
  print("初次运行：")
  cpu_time=timeit.timeit(cpu_run,number=number)
  gpu_time=timeit.timeit(gpu_run,number=number)
  print("cpu计算时间：",cpu_time)
  print("Gpu计算时间：",gpu_time)

  print("再次运行：")
  cpu_time=timeit.timeit(cpu_run,number=number)
  gpu_time=timeit.timeit(gpu_run,number=number)
  print("cpu计算时间：",cpu_time)
  print("Gpu计算时间：",gpu_time)
  
run()

可能T4显卡不太好吧…体现不出太大的效果，也可能是GPU在公用或者还没热身。

自动 求导：

公式：
f(x)=x^n

微分(导数)：
f'(x)=n*x^(n-1)

例：
y=x^2
微分(导数)：
d y/dx=2x^(2-1)=2x

x = tf.constant(10.)   # 定义常数变量值
with tf.GradientTape() as tape:   #调用tf底下的求导函数
  tape.watch([x])   # 使用tape.watch（）去观察和跟踪watch
  y=x**2

dy_dx = tape.gradient(y,x)
print(dy_dx)

运行结果：tf.Tensor(20.0, shape=(), dtype=float32)

数据 预处理之统一 数组 维度

对拿到的脏数据进行预处理的时候需要进行统一数组维度操作，使用 tensorflow.keras.pre processing.seq ue nce 底下的pad_seque nc es函数，比如下面有三个不等长的数组，我们需要对数据处理成相同的长度，可以进行左边或者补个数

import numpy as np
import pprint as pp #让打印出来的更加好看
from tensorflow.keras.preprocessing.sequence import pad_sequences

comment1 = [1,2,3,4]
comment2 = [1,2,3,4,5,6,7]
comment3 = [1,2,3,4,5,6,7,8,9,10]

x_train = np.array([comment1, comment2, comment3], dtype=object)
print(), pp.pprint(x_train)

# 左补0，统一数组长度
x_test = pad_sequences(x_train)
print(), pp.pprint(x_test)

# 左补255，统一数组长度
x_test = pad_sequences(x_train, value=255)
print(), pp.pprint(x_test)

# 右补0，统一数组长度
x_test = pad_sequences(x_train, padding="post")
print(), pp.pprint(x_test)

# 切取数组长度, 只保留后3位
x_test = pad_sequences(x_train, maxlen=3)
print(), pp.pprint(x_test)

# 切取数组长度, 只保留前3位
x_test = pad_sequences(x_train, maxlen=3, truncating="post")
print(), pp.pprint(x_test)

array([list([1, 2, 3, 4]), list([1, 2, 3, 4, 5, 6, 7]),
       list([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])], dtype=object)

array([[ 0,  0,  0,  0,  0,  0,  1,  2,  3,  4],
       [ 0,  0,  0,  1,  2,  3,  4,  5,  6,  7],
       [ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10]], dtype=int32)

array([[255, 255, 255, 255, 255, 255,   1,   2,   3,   4],
       [255, 255, 255,   1,   2,   3,   4,   5,   6,   7],
       [  1,   2,   3,   4,   5,   6,   7,   8,   9,  10]], dtype=int32)

array([[ 1,  2,  3,  4,  0,  0,  0,  0,  0,  0],
       [ 1,  2,  3,  4,  5,  6,  7,  0,  0,  0],
       [ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10]], dtype=int32)

array([[ 2,  3,  4],
       [ 5,  6,  7],
       [ 8,  9, 10]], dtype=int32)

array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]], dtype=int32)

(None, None)

定义变量和常量

tf中变量定义为Variable，常量Tensor（这里懂了吧，pytorch里面都是Tensor，但是tf里面的Tensor 代表向量其实也是可变的），要注意的是Variable数组和变量数值之间的加减乘除可以进行广播机制的运算，而且常量和变量之间也是可以相加的。

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.system("cls")

import tensorflow as tf

################################
# 定义变量
a = tf.Variable(1)
b = tf.Variable(1.)
c = tf.Variable([1.])
d = tf.Variable(1., dtype=tf.float32)

print("-" * 40)
print(a)
print(b)
print(c)
print(d)

# print(a+b)  # error:类型不匹配
print(b+c)    # 注意这里是Tensor类型
print(b+c[0]) # 注意这里是Tensor类型

################################
# 定义Tensor
x1 = tf.constant(1)
x2 = tf.constant(1.)
x3 = tf.constant([1.])
x4 = tf.constant(1, dtype=tf.float32)

print("-" * 40)
print(x1)
print(x2)
print(x3)
print(x4)

print(x2+x3[0])

运行结果：

—————————————-

<tf.Variable ‘Variable:0’ shape=() dtype=int32, numpy=1> <tf.Variable ‘Variable:0’ shape=() dtype=float32, numpy=1.0> <tf.Variable ‘Variable:0’ shape=(1,) dtype=float32, numpy=array([1.], dtype=float32)> <tf.Variable ‘Variable:0’ shape=() dtype=float32, numpy=1.0> tf.Tens or([2.], shape=(1,), dtype=float32) tf.Tensor(2.0, shape=(), dtype=float32)

—————————————-

tf.Tensor(1, shape=(), dtype=int32) tf.Tensor(1.0, shape=(), dtype=fl oat32) tf.Tensor([1.], shape=(1,), dtype=float32) tf.Tensor(1.0, shape=(), dtype=float32) tf.Tensor(2.0, shape=(), dtype=float32)

训练 模型的时候 设备变量的设置

使用Variable：

如果定义整数默认定义在CPU，定义浮点数默认在GPU上，但是咱们在tf2.0上不用去关心他的变量类型，因为2.0进行运算的变量都在GPU上进行运算（前提上本地有GPU).

使用 identity 指定变量所定义的设备，在2.0其实不用管了，1.0可能代码得有两个不同设备的版本，但在2.0就不需要在意这个问题了。

################################
# 定义变量后看设备
a = tf.Variable(1)
b = tf.Variable(10.)

print("-" * 40)
print("a.device:", a.device, a) # CPU
print("b.device:", b.device, b) # GPU

################################
# 定义Tensor后看设备
x1 = tf.constant(100)
x2 = tf.constant(1000.)

print("-" * 40)
print("x1.device:", x1.device, x1) # CPU
print("x2.device:", x2.device, x2) # CPU

################################
print("-" * 40)

# CPU+CPU
ax1 = a + x1
print("ax1.device:", ax1.device, ax1) # GPU

# CPU+GPU
bx2 = b + x2
print("bx2.device:", bx2.device, bx2) # GPU

################################
# 指定GPU设备定义Tensor
gpu_a = tf.identity(a)
gpu_x1 = tf.identity(x1)

print("-" * 40)
print("gpu_a.device:", gpu_a.device, gpu_a)
print("gpu_x1.device:", gpu_x1.device, gpu_x1)

生成 随机数据

其实tf和numpy在创建上是大同小异的，除了变量类型不一样。

a = np.ones(12)
print(a)
a = tf.convert_to_tensor(a)#其实没必要转换，直接像下面的方法进行定义。
a = tf.zeros(12)
a = tf.zeros([4,3])
a = tf.zeros([4,6,3])
b = tf.zeros_like(a)
a = tf.ones(12)
a = tf.ones_like(b)
a = tf.fill([3,2], 10.)
a = tf.random.normal([12])
a = tf.random.normal([4,3])
a = tf.random.truncated_normal([3,2])
a = tf.random.uniform([4,3], minval=0, maxval=10)
a = tf.random.uniform([12], minval=0, maxval=10, dtype=tf.int32)
a = tf.range([12], dtype=tf.int32)
b = tf.random.shuffle(a)
print(b)

代码我就不贴了。

交叉熵损失CE和均方误差函数MSE

假设 batch=1

直接看怎么用，以图像分类为例，输出是类别个数，选择最大神经原的下标，然后进行独热编码把它变成[1,0,0,0,…]，然后就可以与softmax之后的输出概率值之间做交叉熵损失。

rows = 1
out = tf.nn.softmax(tf.random.uniform([rows,2]),axis=1)
print("out:", out)
print("预测值：", tf.math.argmax(out, axis=1), "n")

y = tf.range(rows)
print("y:", y, "n")

y = tf.one_hot(y, depth=10)
print("y_one_hot:", y, "n")

loss = tf.keras.losses.binary_crossentropy(y,out)
# loss = tf.keras.losses.mse(y, out)
print("row loss", loss, "n")

假设batch=2

rows = 2
out = tf.random.uniform([rows,1])
print("预测值：", out, "n")

y = tf.constant([1])
print("y:", y, "n")

# y = tf.one_hot(y, depth=1)

print("y_one_hot:", y, "n")

loss = tf.keras.losses.mse(y,out)
# loss = tf.keras.losses.mse(y, out)
print("row loss", loss, "n")

loss = tf.reduce_mean(loss)
print("总体损失：", loss, "n")

总损失就是一个 batch的损失求均值。

全连接Dense层

###################################################
# Dense: y=wx+b
rows = 1
net = tf.keras.layers.Dense(1) # 一个隐藏层，一个神经元
net.build((rows, 1)) # （编译）每个训练数据有1个特征
print("net.w:", net.kernel) # 参数个数
print("net.b:", net.bias) # 和Dense数一样

假设有一个特征输出，如果讲bulid 参数改成（rows,3),那么神经元个数的w参数输出就变成了(3,1)大小的数据。

维度 变换 reshape

跟numpy一毛一样不用看了

# 10张彩色图片
a = tf.random.normal([10,28,28,3])
print(a)
print(a.shape) # 形状
print(a.ndim)  # 维度

b = tf.reshape(a, [10, 784, 3])
print(b)
print(b.shape) # 形状
print(b.ndim)  # 维度

c = tf.reshape(a, [10, -1, 3])
print(c)
print(c.shape) # 形状
print(c.ndim)  # 维度

d = tf.reshape(a, [10, 784*3])
print(d)
print(d.shape) # 形状
print(d.ndim)  # 维度

e = tf.reshape(a, [10, -1])
print(e)
print(e.shape) # 形状
print(e.ndim)  # 维度

增加或减小维度

a = tf.range([24])
# a = tf.reshape(a, [4,6])
print(a)
print(a.shape)
print(a.ndim)

# 增加一个维度，相当于[1,2,3]->[[1,2,3]]
b = tf.expand_dims(a, axis=0)
print(b)
print(b.shape)
print(b.ndim)

# 减少维度，相当于[[1,2,3]]->[1,2,3]
c = tf.squeeze(b, axis=0)
print(c)
print(c.shape)
print(c.ndim)

数组合并

真t和numpy一毛一样

####################################################
# 数组合并
# tf.concat
a = tf.zeros([2,4,3])
b = tf.ones([2,4,3])

print(a)
print(b)

# 0轴合并，4,4,3
c = tf.concat([a,b], axis=0)
print(c)

# 1轴合并，2,8,3
c = tf.concat([a,b], axis=1)
print(c)

# 2轴合并，2,4,6
c = tf.concat([a,b], axis=2)
print(c)

# 扩充一维，例如把多个图片放入一个大数组中 -> 2,2,4,3
c = tf.stack([a,b], axis=0)
print(c)

# 降低维数，拆分数组
m, n = tf.unstack(c, axis=0)
print(m)
print(n)

广播机制：

a = tf.constant([1, 2, 3])
print(a)

x = 1
print(a + x)

b = tf.broadcast_to(a, [3, 3])
print(b)

x = 10
print(b * x)

运行结果：

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

tf.Tensor([2 3 4], shape=(3,), dtype=int32)

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

tf.Tensor( [[10 20 30] [10 20 30] [10 20 30]], shape=(3, 3), dtype=int32)

简单范数运算

def log(prefix="", val=""):
    print(prefix, val, "n")

# 2范数：平方和开根号
a = tf.fill([1,2], value=2.)
log("a:", a)
b = tf.norm(a) # 计算a的范数
log("a的2范数b:", b)

# 计算验证
a = tf.square(a)
log("a的平方:", a)

a = tf.reduce_sum(a)
log("a平方后的和:", a)

b = tf.sqrt(a)
log("a平方和后开根号:", b)

# a = tf.range(10, dtype=tf.float32)

矩阵转置

#####################################################
# 矩阵转置
a = tf.range([12])
a = tf.reshape(a, [4,3])
print(a)

b = tf.transpose(a) # 行列交换
print(b)

# 1张4x4像素的彩色图片
a = tf.random.uniform([4,4,3], minval=0, maxval=10, dtype=tf.int32)
print(a)

# 指定变换的轴索引
b = tf.transpose(a, perm=[0,2,1])
print(b)

# 把刚才的b再变换回来
c = tf.transpose(b, perm=[0,2,1])
print(c)