TensorFlow读书笔记

1.神经网络计算

1.1初认神经网络设计过程-鸢尾花分类问题

import tensorflow as tf

# 设置参数w的随机初始值为5，设定为可训练（即vaiable形式？）
w = tf.Variable(tf.constant(5, dtype=tf.float32))
# 学习率
lr = 0.2
# 循环次数
epoch = 40

for epoch in range(epoch):
    with tf.GradientTape() as tape:  # with结构到grad框起到了梯度计算的过程
        loss = tf.square(w + 1)  # 损失函数定义为w+1的平方
    grads = tape.gradient(loss, w)  # gradinet函数告知对谁求导

    w.assign_sub(lr * grads)  # assign_sub做自减，即w-=
    print("After %s epoch,w is %f,loss is %f" % (epoch, w.numpy(), loss))

1.2 张量生成

tensorflow中的tensor就是张量，是多维数组（多维列表），用阶来表示张量的维数，判断张量是几阶的可以看有几个方括号

import tensorflow as tf
a=tf.constant([1,5],dtype=tf.int64)
#直接打印a，会输出a的所有信息
print(a)

#打印a的数据类型
print(a.dtype)

#打印a的形状
print(a.shape)

 

 很多时候数据是用numpy给出的，可以通tf.convert_to_tensor(数据名，dtype=数据类型（可选）)将其转化为tensor数据类型

import tensorflow as tf
import numpy as np
a=np.arange(0,5)
b=tf.convert_to_tensor(a,dtype=tf.int64)
print(a)
print(b)

 

 

 注意对于维度：
一维直接写个数
二维用【行，列】
多维用【m,j,k…】

import tensorflow as tf
a=tf.zeros([2,3])
b=tf.ones(4)
c=tf.fill([2,2],9)
print(a)
print(b)
print(c)

生成随机数

• 生产正态分布的随机数，默认均值为0，标准差为1
  tf.random.normal(维度,mean=均值,stddev=标准差)
  如果希望生成的随机数更集中可以采用截断式正态分布，可以保证生成的数在两倍标准差之内

• 生成截断式正态分布的随机数
  tf.random.truncated_normal(维度,mean=均值,stddev=标准差)

• 生成均匀分布随机数[minval,maxval)，注意是前闭后开
  tf.random.uniform(维度,minval=最小值,maxval=最大值)

  import tensorflow as tf
  d=tf.random.normal([2,2],mean=0.5,stddev=1)
  print(d)
  e=tf.random.truncated_normal([2,2],mean=0.5,stddev=1)
  print(e)
  f=tf.random.uniform([2,2],minval=0,maxval=1)
  print(f)

  

  常用函数

• 强制tensor转换为该数据类型      tf.cast(张量名,dtype=数据类型 )
• 计算张量维度上元素的最小值     tf.reduce_min(张量名)
• 计算张量维度上的元素最大值     tf.reduce_max(张量名)

• import tensorflow as tf
  x1=tf.constant([1.,2.,3.],dtype=tf.float64)
  print(x1)
  x2=tf.cast(x1,tf.int32)
  print(tf.reduce_min(x2),'\n',tf.reduce_max(x2))

  
  

  import tensorflow as tf
  x1=tf.constant([1.,2.,3.],dtype=tf.float64)
  print(x1)
  x2=tf.cast(x1,tf.int32)
  print(tf.reduce_min(x2),'\n',tf.reduce_max(x2))

  

  

  import tensorflow as tf
  a=tf.ones([1,3])
  b=tf.fill([1,3],3.)
  print(a)
  print(b)
  print(tf.add(a,b))
  print(tf.subtract(a,b))
  print(tf.multiply(a,b))
  print(tf.divide(b,a))

  

  

  import tensorflow as tf
  
  
  features=tf.constant([12,23,10,17])
  labels=tf.constant([0,1,1,0])
  dataset=tf.data.Dataset.from_tensor_slices((features,labels)) #把特征和标签配对
  print(dataset)
  for element in dataset:
      print(element)

  

  

  import tensorflow as tf
  features=tf.constant([12,23,10,17])
  labels=tf.constant([0,1,1,0])
  dataset=tf.data.Dataset.from_tensor_slices((features,labels)) #把特征和标签配对
  with tf.GradientTape()as tape:
      w=tf.Variable(tf.constant(3.0))
      loss=tf.pow(w,2)#损失函数为w的平方
  grad=tape.gradient(loss,w)
  print(grad)

  

  

   

   

• import tensorflow as tf
  seq=['one','two','three']
  for i,element in enumerate(seq):#i用来接收索引，element用来接收元素
      print(i,element)

  

  

  import tensorflow as tf
  classes=3
  labels=tf.constant([1,0,2])
  output=tf.one_hot(labels,depth=classes)
  print(output)

  

  

  

  import tensorflow as tf
  w=tf.Variable(4) #先被定义为可训练的类型
  w.assign_sub(1)
  print(w)

  

  

  import tensorflow as tf
  import numpy as np
  test=np.array([[1,2,3],[2,3,4],[5,4,3],[8,7,2]])
  print(test)
  print(tf.argmax(test,axis=0))#返回每一列（经度）最大值索引
  print(tf.argmax(test,axis=1))#返回每一行（纬度）最大值索引

  

  #导入相关包

• from sklearn.datasets import load_iris#导入数据集
  from pandas import DataFrame
  import pandas as pd
  
  
  x_data=load_iris().data #返回iris数据集的所有输入
  y_data=load_iris().target  #返回iris数据集中所有标签
  
  
  x_data=DataFrame(x_data,columns=['花萼长度','花萼宽度','花瓣长度','花萼宽度'])
  pd.set_option('display.unicode.east_asian_width',True) #设置列名对其
  
  x_data['类别']=y_data #添加一列，列标签为列表
  x_data
  #导入相关包
  from sklearn.datasets import load_iris#导入数据集
  from pandas import DataFrame
  import pandas as pd
  
  
  x_data=load_iris().data #返回iris数据集的所有输入
  y_data=load_iris().target  #返回iris数据集中所有标签
  
  
  x_data=DataFrame(x_data,columns=['花萼长度','花萼宽度','花瓣长度','花萼宽度'])
  pd.set_option('display.unicode.east_asian_width',True) #设置列名对其
  
  x_data['类别']=y_data #添加一列，列标签为列表
  x_data

• 

• # 导入所需模块
  import tensorflow as tf
  from sklearn import datasets
  from matplotlib import pyplot as plt
  
  import numpy as np
  
  # 导入数据，分别为输入特征和标签
  x_data = datasets.load_iris().data
  y_data = datasets.load_iris().target
  
  # 随机打乱数据（因为原始数据是顺序的，顺序不打乱会影响准确率）
  # seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样（为方便教学，以保每位同学结果一致）
  np.random.seed(116)  # 使用相同的seed，保证输入特征和标签一一对应
  np.random.shuffle(x_data)
  np.random.seed(116)
  np.random.shuffle(y_data)
  tf.random.set_seed(116)
  
  # 将打乱后的数据集分割为训练集和测试集，训练集为前120行，测试集为后30行
  x_train = x_data[:-30]
  y_train = y_data[:-30]
  x_test = x_data[-30:]
  y_test = y_data[-30:]
  
  # 转换x的数据类型，否则后面矩阵相乘时会因数据类型不一致报错
  x_train = tf.cast(x_train, tf.float32)
  x_test = tf.cast(x_test, tf.float32)
  
  # from_tensor_slices函数使输入特征和标签值一一对应。（把数据集分批次，每个批次batch组数据）
  train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
  test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
  
  # 生成神经网络的参数，4个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元
  # 用tf.Variable()标记参数可训练
  # 使用seed使每次生成的随机数相同（方便教学，使大家结果都一致，在现实使用时不写seed）
  w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
  b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
  
  #定义超参数
  lr = 0.1  # 学习率为0.1
  train_loss_results = []  # 将每轮的loss记录在此列表中，为后续画loss曲线提供数据
  test_acc = []  # 将每轮的acc记录在此列表中，为后续画acc曲线提供数据
  epoch = 500  # 循环500轮
  loss_all = 0  # 每轮分4个step，loss_all记录四个step生成的4个loss的和
  
  # 训练部分
  for epoch in range(epoch):  #数据集级别的循环，每个epoch循环一次数据集
      for step, (x_train, y_train) in enumerate(train_db):  #batch级别的循环 ，每个step循环一个batch
          with tf.GradientTape() as tape:  # with结构记录梯度信息
              y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
              y = tf.nn.softmax(y)  # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）
              y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式，方便计算loss和accuracy
              loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
              loss_all += loss.numpy()  # 将每个step计算出的loss累加，为后续求loss平均值提供数据，这样计算的loss更准确
          # 计算loss对各个参数的梯度
          grads = tape.gradient(loss, [w1, b1])
  
          # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
          w1.assign_sub(lr * grads[0])  # 参数w1自更新
          b1.assign_sub(lr * grads[1])  # 参数b自更新
  
      # 每个epoch，打印loss信息
      print("Epoch {}, loss: {}".format(epoch, loss_all/4))
      train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
      loss_all = 0  # loss_all归零，为记录下一个epoch的loss做准备
  
      # 测试部分
      # total_correct为预测对的样本个数, total_number为测试的总样本数，将这两个变量都初始化为0
      total_correct, total_number = 0, 0
      for x_test, y_test in test_db:
          # 使用更新后的参数进行预测
          y = tf.matmul(x_test, w1) + b1#计算前向传播预测结果
          y = tf.nn.softmax(y)#变为概率分布
          pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即预测的分类
          # 将pred转换为y_test的数据类型
          pred = tf.cast(pred, dtype=y_test.dtype)
          # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int型
          correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
          # 将每个batch的correct数加起来
          correct = tf.reduce_sum(correct)
          # 将所有batch中的correct数加起来
          total_correct += int(correct)
          # total_number为测试的总样本数，也就是x_test的行数，shape[0]返回变量的行数
          total_number += x_test.shape[0]
      # 总的准确率等于total_correct/total_number
      acc = total_correct / total_number
      test_acc.append(acc)
      print("Test_acc:", acc)
      print("--------------------------")
  
  # 绘制 loss 曲线
  plt.title('Loss Function Curve')  # 图片标题
  plt.xlabel('Epoch')  # x轴变量名称
  plt.ylabel('Loss')  # y轴变量名称
  plt.plot(train_loss_results, label="$Loss$")  # 逐点画出trian_loss_results值并连线，连线图标是Loss
  plt.legend()  # 画出曲线图标
  plt.show()  # 画出图像
  
  # 绘制 Accuracy 曲线
  plt.title('Acc Curve')  # 图片标题
  plt.xlabel('Epoch')  # x轴变量名称
  plt.ylabel('Acc')  # y轴变量名称
  plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线，连线图标是Accuracy
  plt.legend()
  plt.show()

  

  损失函数

  

   acc准确率 计算正确的占总数的

  

   

   

二.计算图session Tensor

1.tensorflow将定义的tensor作为节点保存，即构造图过程：

import tensorflow as tf
a=tf.constant(32) #创建常量
b=tf.constant(10) #创建常量
c=tf.add(a,b)
print(a)
print(b)
print(c)

　　　　没有具体的值，要想显示具体的值，需要开启session

开启session：

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
a=tf.constant(32) #创建常量
b=tf.constant(10) #创建常量
c=tf.add(a,b)
print(sess.run(a))
print(sess.run([a,b]))
print(sess.run([a,b,c]))

 关闭session代码：

sess.close()
将session产生的结果保存在一个变量中，下面的py是一个正常的数值

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
a=tf.constant(32) #创建常量
b=tf.constant(10) #创建常量
c=tf.add(a,b)
#将上面产生的结果保存在一个变量中
py_a=sess.run(a)
print(type(py_a))

py_r=sess.run([a,b,c])
print(type(py_r))
print(py_r[0],py_r[1],py_r[2])

2.OP 矩阵 随机化 Variable

2.1 OP

op：tensorflow具有很多基本操作，这些操作定义为op

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
a=tf.constant(32) #创建常量
b=tf.constant(10) #创建常量
c=tf.add(a,b)
#加法a+b+b
d=tf.add_n([a,b,b])
print(d)

#减法a-b
e=tf.subtract(a,b)
print(b)

#乘法a*b
f=tf.multiply(a,b)
print(f)

#除法a/b
g=tf.divide(a,b)
print(g)

#求余
h=tf.truncatemod(a,b)
print(h)

print(sess.run([d,e,f,g,h]))

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
a=tf.constant(32) #创建常量
b=tf.constant(10) #创建常量
c=tf.add(a,b)
#数值类型转换
a_float=tf.cast(a,dtype=tf.float32)
b_float=tf.cast(b,dtype=tf.float32)

#sin(a)
i=tf.sin(a_float)
print(i)

#exp(1/a)
j=tf.exp(tf.divide(1.0,a_float))
print(j)

#i+log(i)
k=tf.add(i,tf.math.log(i))
print(k)

print(sess.run([i,j,k]))

2.2 tensorflow矩阵及运算

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
#从4维向量生成（2,2）的矩阵
mat_a=tf.constant([1,2,3,4])
mat_a=tf.reshape(mat_a,(2,2))
print('mat_a：\n',sess.run(mat_a))

#生成2*3的矩阵
mat_b=tf.constant([1,3,5,7,9,11])
mat_b=tf.reshape(mat_b,(2,3))
print('mat_b：\n',sess.run(mat_b))

#矩阵乘法
mat_c=tf.matmul(mat_a,mat_b)
print('mat_c：\n',sess.run(mat_c))

2.3 随机化

tensorflow提供了多种随机化的方式：

（1）random.normal: 正太分布随机数，均值mean,标准差stddev
（2）random.truncated_normal:截断正态分布随机数，均值mean,标准差stddev,不过只保留（3）[mean-2stddev,mean+2stddev]范围内的随机数
（4）random.uniform:均匀分布随机数，范围为[minval,maxval]

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
#标准正态分布随机
#注意tensorflow版本区别，在1.0中是random_normal
rand_normal=tf.random.normal((1,10),mean=0.0,stddev=1.0,dtype=tf.float32,seed=None)

#truncated正态随机
truncated_normal=tf.random.truncated_normal((1,10),mean=0.0,stddev=1.0,dtype=tf.float32,seed=None)

#均匀分布随机
rand_uniform=tf.random.uniform((1,10),minval=0.0,maxval=1.0,dtype=tf.float32,seed=None)

print(sess.run(rand_normal))
print(sess.run(truncated_normal))
print(sess.run(rand_uniform))

2.4 Variable

Variable是tensorflow下可以修改值的tensor，它需要定义一个初始值，可以是数值、类别或者numpy矩阵，也可以直接是tensor
在使用variable时，我们必须初始化这个variable，也就是条用它们的初始化方法
在初始化完成之后，同样需要使用session来获得vaiable的值

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
var_a=tf.Variable(0,dtype=tf.int32)
var_b=tf.Variable([1,2],dtype=tf.float32)
var_w=tf.Variable(tf.zeros(1024,10))


#开启交互式session
sess= tf.compat.v1.InteractiveSession()

#一次性初始化所有变量
init=tf.compat.v1.global_variables_initializer()
sess.run(init)

#初始化某些变量
init_ab=tf.compat.v1.variables_initializer([var_a,var_b])
init_ab.run()

#初始化某个变量，通过调用变量的初始化函数来实现
var_w.initializer.run()

W=tf.compat.v1.Variable(10)
sess.run(W.initializer)
print(W)
print(sess.run(W))
print(W.eval())

 实现对variable赋值
可以通过assign对variable进行赋值，但这是一个操作，必须执行之后才能产生效果

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
var_a=tf.Variable(0,dtype=tf.int32)
var_b=tf.Variable([1,2],dtype=tf.float32)
var_w=tf.Variable(tf.zeros(1024,10))


#开启交互式session
sess= tf.compat.v1.InteractiveSession()

#一次性初始化所有变量
init=tf.compat.v1.global_variables_initializer()
sess.run(init)

#初始化某些变量
init_ab=tf.compat.v1.variables_initializer([var_a,var_b])
init_ab.run()

#初始化某个变量，通过调用变量的初始化函数来实现
var_w.initializer.run()

W=tf.compat.v1.Variable(10)
#一开始只是赋值但是w的值没有改变
W.assign(100)
W.initializer.run() #只是run了w的初始化，而w的初始化为10
print(W.eval())

assign_op=W.assign(100)
W.initializer.run()
assign_op.eval() #只有运行了这里w的值才会发生改变
print(W.eval())

3. 占位符占位符概念：

图的节点可以没有具体的值，tensorflow根据这个逻辑定制了占位符(placeholder)的概念，它在构建图的时候占据图中一个位置，然后在执行图的时候才会带入具体的值
定义了占位符之后可以随便带入不同的数值来执行下面的操作，还需给占位符赋值，由于placeholder没有具体的值，那么我们在执行图的过程中需要填入具体的值，那么久需要一个字典：它的key是placeholder，value就是具体的值，这个就是feed_dict

import tensorflow as tf
tf.compat.v1.disable_eager_execution() #因为安装的是高版本的，要想session能用必须先写这个
sess= tf.compat.v1.Session()
var_a=tf.Variable(0,dtype=tf.int32)
var_b=tf.Variable([1,2],dtype=tf.float32)
var_w=tf.Variable(tf.zeros(1024,10))


#开启交互式session
sess= tf.compat.v1.InteractiveSession()

#一次性初始化所有变量
init=tf.compat.v1.global_variables_initializer()
sess.run(init)

#初始化某些变量
init_ab=tf.compat.v1.variables_initializer([var_a,var_b])
init_ab.run()

#初始化某个变量，通过调用变量的初始化函数来实现
var_w.initializer.run()

W=tf.compat.v1.Variable(10)
#一开始只是赋值但是w的值没有改变
W.assign(100)
import tensorflow.compat.v1 as tf #对于v1,v2不兼容问题可以通过这个解决
tf.disable_v2_behavior()

#定义一个占位符（类型必须定义，否则报错，shape可有可无，缺省的话默认其为布尔类型）
tf.placeholder(dtype=tf.float32,shape=None,name=None)

#定义一个float32型的占位符，它是一个长度为3的向量
a=tf.placeholder(tf.float32,shape=[3])

#定义一个bool型的占位符，它是一个1*2的矩阵
b=tf.placeholder(tf.bool,shape=[1,2])
#给占位符赋值
#a在上面定义了为3位的向量
print(sess.run(a,feed_dict={a:[1,2,3]}))
#b在上面定义了为1*2的矩阵
print(sess.run([a,b],feed_dict={a:[1,2,3],b:[[True,False]]}))