tensorflow的基本操作

TensorFlow™是一个基于数据流编程（dataflow programming）的符号数学系统，被广泛应用于各类机器学习（machine learning）算法的编程实现，其前身是谷歌的神经网络算法库DistBelief [1] 。

Tensorflow拥有多层级结构，可部署于各类服务器、PC终端和网页并支持GPU和TPU高性能数值计算，被广泛应用于谷歌内部的产品开发和各领域的科学研究

Tensorflow 的基本操作

#打印tf版本获取常量值
import tensorflow as tf
print(tf.__version__)
a=tf.constant(2.0)
print(a)

结果：

2.9.0-dev20220327
Tensor("Const_15:0", shape=(), dtype=float32)

#下列代码可以在2.x中使用1.x的代码，不过一些被删除的代码无法使用
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
a=tf.constant(2.0)
with tf.Session()as sess:
print(sess.run(a))
print(a)

Tensor("Const_21:0", shape=(), dtype=int32)
Tensor("Const_22:0", shape=(), dtype=int32)
Tensor("Add_2:0", shape=(), dtype=int32)

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

32
[32, 10]
[32, 10, 42]

#将上面产生的结果保存在一个变量中
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])

<class 'numpy.int32'>
<class 'list'>
32 10 42

#基本运算
#加法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]))
#数值类型转换
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]))

Tensor("AddN_10:0", shape=(), dtype=int32)
Tensor("Const_22:0", shape=(), dtype=int32)
Tensor("Mul_5:0", shape=(), dtype=int32)
Tensor("truediv_5:0", shape=(), dtype=float64)
Tensor("TruncateMod_5:0", shape=(), dtype=int32)
[52, 22, 320, 3.2, 2]
Tensor("Sin:0", shape=(), dtype=float32)
Tensor("Exp:0", shape=(), dtype=float32)
Tensor("Add_3:0", shape=(), dtype=float32)
[0.5514267, 1.0317434, -0.043819606]

#矩阵运算
#从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))
#用了session模式好像用不了书上的numpy函数

mat_a：
 [[1 2]
 [3 4]]
mat_b：
 [[ 1  3  5]
 [ 7  9 11]]
mat_c：
 [[15 21 27]
 [31 45 59]]

#随机化实现
#标准正态分布随机
#注意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.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))

[[ 1.1016903   1.13558     0.28250527 -2.1385217   2.7722688  -1.3720158
   0.7621916  -1.0713987   0.36439985  0.68659556]]
[[ 1.3360797  -0.52967274 -0.09540483  0.70260465  1.2980912   0.5778198
  -1.2894628   0.88082093 -1.2023339  -0.57034177]]
[[0.43418252 0.45881903 0.25752425 0.54407597 0.6047938  0.12356377
  0.5012429  0.07523882 0.05481243 0.4527197 ]]

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.InteractiveSession()

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

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

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

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

<tf.Variable 'Variable_3:0' shape=() dtype=int32_ref>
10
10

W=tf.Variable(10)
sess.run(W.initializer)
print(W)
print(sess.run(W))
print(W.eval()) #通过调用w内置的方法

<tf.Variable 'Variable_4:0' shape=() dtype=int32_ref>
10
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())

10
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]]}))

[1. 2. 3.]
[array([1., 2., 3.], dtype=float32), array([[ True, False]])]

 实际应用：服装的辨别#小写和图片的是运行结果大写是代码

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

2.9.0-dev20220327

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)

 

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

train_images.shape

(60000, 28, 28)

len(train_labels)

60000

train_labels

array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

len(test_labels)

10000

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

 

 

train_images = train_images / 255.0

test_images = test_images / 255.0

plt.figure(figsize=(10,10))
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i]])
plt.show()

 

model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10)
])

model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])

model.fit(train_images, train_labels, epochs=10)

Epoch 1/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.4980 - accuracy: 0.8246
Epoch 2/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3734 - accuracy: 0.8652
Epoch 3/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3346 - accuracy: 0.8769
Epoch 4/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3134 - accuracy: 0.8862
Epoch 5/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2952 - accuracy: 0.8908
Epoch 6/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2794 - accuracy: 0.8971
Epoch 7/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2682 - accuracy: 0.9002
Epoch 8/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2575 - accuracy: 0.9036
Epoch 9/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2466 - accuracy: 0.9079
Epoch 10/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2384 - accuracy: 0.9110

<keras.callbacks.History at 0x1fb2232e2b0>

 

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print('\nTest accuracy:', test_acc)

313/313 - 0s - loss: 0.3345 - accuracy: 0.8818 - 377ms/epoch - 1ms/step

Test accuracy: 0.8817999958992004

probability_model = tf.keras.Sequential([model,
tf.keras.layers.Softmax()])

predictions = probability_model.predict(test_images)

313/313 [==============================] - 0s 917us/step

predictions[0]

array([7.0977298e-06, 3.7750314e-09, 3.2938171e-08, 1.5178973e-08,
       1.3609517e-07, 9.2637604e-03, 1.0997358e-06, 8.3959095e-02,
       1.7186796e-06, 9.0676707e-01], dtype=float32)

np.argmax(predictions[0])

9

test_labels[0]

9

def plot_image(i, predictions_array, true_label, img):
predictions_array, true_label, img = predictions_array, true_label[i], img[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])

plt.imshow(img, cmap=plt.cm.binary)

predicted_label = np.argmax(predictions_array)
if predicted_label == true_label:
color = 'blue'
else:
color = 'red'

plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
100*np.max(predictions_array),
class_names[true_label]),
color=color)

def plot_value_array(i, predictions_array, true_label):
predictions_array, true_label = predictions_array, true_label[i]
plt.grid(False)
plt.xticks(range(10))
plt.yticks([])
thisplot = plt.bar(range(10), predictions_array, color="#777777")
plt.ylim([0, 1])
predicted_label = np.argmax(predictions_array)

thisplot[predicted_label].set_color('red')
thisplot[true_label].set_color('blue')

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i], test_labels)
plt.show()

 

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i], test_labels)
plt.show()

 

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
plt.subplot(num_rows, 2*num_cols, 2*i+1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(num_rows, 2*num_cols, 2*i+2)
plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

 

 

# Grab an image from the test dataset.
img = test_images[1]

print(img.shape)

(28, 28)

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)

(1, 28, 28) 

predictions_single = probability_model.predict(img)

print(predictions_single)

1/1 [==============================] - 0s 14ms/step
[[9.8042750e-05 3.1405954e-11 9.9825567e-01 4.2586479e-10 6.5974909e-04
  4.2871398e-10 9.8653103e-04 1.1689199e-14 2.4741189e-09 2.6639923e-14]]

plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)